]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added wxMemoryDC::Clear()
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1663 #define SWIG_From_int PyInt_FromLong
1664 /*@@*/
1665
1666
1667 #if ! wxUSE_HOTKEY
1668 enum wxHotkeyModifier
1669 {
1670 wxMOD_NONE = 0,
1671 wxMOD_ALT = 1,
1672 wxMOD_CONTROL = 2,
1673 wxMOD_SHIFT = 4,
1674 wxMOD_WIN = 8
1675 };
1676 #define wxEVT_HOTKEY 9999
1677 #endif
1678
1679 static const wxString wxPyEmptyString(wxEmptyString);
1680 static wxString wxObject_GetClassName(wxObject *self){
1681 return self->GetClassInfo()->GetClassName();
1682 }
1683 static void wxObject_Destroy(wxObject *self){
1684 delete self;
1685 }
1686
1687 #ifndef __WXMAC__
1688 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1689 #endif
1690
1691
1692 #include <limits.h>
1693
1694
1695 SWIGINTERN int
1696 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1697 const char *errmsg)
1698 {
1699 if (value < min_value) {
1700 if (errmsg) {
1701 PyErr_Format(PyExc_OverflowError,
1702 "value %ld is less than '%s' minimum %ld",
1703 value, errmsg, min_value);
1704 }
1705 return 0;
1706 } else if (value > max_value) {
1707 if (errmsg) {
1708 PyErr_Format(PyExc_OverflowError,
1709 "value %ld is greater than '%s' maximum %ld",
1710 value, errmsg, max_value);
1711 }
1712 return 0;
1713 }
1714 return 1;
1715 }
1716
1717
1718 SWIGINTERN int
1719 SWIG_AsVal_long(PyObject* obj, long* val)
1720 {
1721 if (PyNumber_Check(obj)) {
1722 if (val) *val = PyInt_AsLong(obj);
1723 return 1;
1724 }
1725 else {
1726 SWIG_type_error("number", obj);
1727 }
1728 return 0;
1729 }
1730
1731
1732 #if INT_MAX != LONG_MAX
1733 SWIGINTERN int
1734 SWIG_AsVal_int(PyObject *obj, int *val)
1735 {
1736 const char* errmsg = val ? "int" : (char*)0;
1737 long v;
1738 if (SWIG_AsVal_long(obj, &v)) {
1739 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1740 if (val) *val = (int)(v);
1741 return 1;
1742 } else {
1743 return 0;
1744 }
1745 } else {
1746 PyErr_Clear();
1747 }
1748 if (val) {
1749 SWIG_type_error(errmsg, obj);
1750 }
1751 return 0;
1752 }
1753 #else
1754 SWIGINTERNSHORT int
1755 SWIG_AsVal_int(PyObject *obj, int *val)
1756 {
1757 return SWIG_AsVal_long(obj,(long*)val);
1758 }
1759 #endif
1760
1761
1762 SWIGINTERNSHORT int
1763 SWIG_As_int(PyObject* obj)
1764 {
1765 int v;
1766 if (!SWIG_AsVal_int(obj, &v)) {
1767 /*
1768 this is needed to make valgrind/purify happier.
1769 */
1770 memset((void*)&v, 0, sizeof(int));
1771 }
1772 return v;
1773 }
1774
1775
1776 SWIGINTERNSHORT int
1777 SWIG_Check_int(PyObject* obj)
1778 {
1779 return SWIG_AsVal_int(obj, (int*)0);
1780 }
1781
1782 static PyObject *wxSize_Get(wxSize *self){
1783 bool blocked = wxPyBeginBlockThreads();
1784 PyObject* tup = PyTuple_New(2);
1785 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1786 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1787 wxPyEndBlockThreads(blocked);
1788 return tup;
1789 }
1790
1791 SWIGINTERN int
1792 SWIG_AsVal_double(PyObject *obj, double* val)
1793 {
1794 if (PyNumber_Check(obj)) {
1795 if (val) *val = PyFloat_AsDouble(obj);
1796 return 1;
1797 }
1798 else {
1799 SWIG_type_error("number", obj);
1800 }
1801 return 0;
1802 }
1803
1804
1805 SWIGINTERNSHORT double
1806 SWIG_As_double(PyObject* obj)
1807 {
1808 double v;
1809 if (!SWIG_AsVal_double(obj, &v)) {
1810 /*
1811 this is needed to make valgrind/purify happier.
1812 */
1813 memset((void*)&v, 0, sizeof(double));
1814 }
1815 return v;
1816 }
1817
1818
1819 SWIGINTERNSHORT int
1820 SWIG_Check_double(PyObject* obj)
1821 {
1822 return SWIG_AsVal_double(obj, (double*)0);
1823 }
1824
1825
1826 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1827 #define SWIG_From_double PyFloat_FromDouble
1828 /*@@*/
1829
1830 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1831 self->x = x;
1832 self->y = y;
1833 }
1834 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1835 bool blocked = wxPyBeginBlockThreads();
1836 PyObject* tup = PyTuple_New(2);
1837 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1838 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1839 wxPyEndBlockThreads(blocked);
1840 return tup;
1841 }
1842
1843 SWIGINTERNSHORT long
1844 SWIG_As_long(PyObject* obj)
1845 {
1846 long v;
1847 if (!SWIG_AsVal_long(obj, &v)) {
1848 /*
1849 this is needed to make valgrind/purify happier.
1850 */
1851 memset((void*)&v, 0, sizeof(long));
1852 }
1853 return v;
1854 }
1855
1856
1857 SWIGINTERNSHORT int
1858 SWIG_Check_long(PyObject* obj)
1859 {
1860 return SWIG_AsVal_long(obj, (long*)0);
1861 }
1862
1863 static void wxPoint_Set(wxPoint *self,long x,long y){
1864 self->x = x;
1865 self->y = y;
1866 }
1867 static PyObject *wxPoint_Get(wxPoint *self){
1868 bool blocked = wxPyBeginBlockThreads();
1869 PyObject* tup = PyTuple_New(2);
1870 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1871 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1872 wxPyEndBlockThreads(blocked);
1873 return tup;
1874 }
1875 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1876 self->x = x;
1877 self->y = y;
1878 self->width = width;
1879 self->height = height;
1880 }
1881 static PyObject *wxRect_Get(wxRect *self){
1882 bool blocked = wxPyBeginBlockThreads();
1883 PyObject* tup = PyTuple_New(4);
1884 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1885 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1886 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1887 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1888 wxPyEndBlockThreads(blocked);
1889 return tup;
1890 }
1891
1892 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1893 wxRegion reg1(*r1);
1894 wxRegion reg2(*r2);
1895 wxRect dest(0,0,0,0);
1896 PyObject* obj;
1897
1898 reg1.Intersect(reg2);
1899 dest = reg1.GetBox();
1900
1901 if (dest != wxRect(0,0,0,0)) {
1902 bool blocked = wxPyBeginBlockThreads();
1903 wxRect* newRect = new wxRect(dest);
1904 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1905 wxPyEndBlockThreads(blocked);
1906 return obj;
1907 }
1908 Py_INCREF(Py_None);
1909 return Py_None;
1910 }
1911
1912
1913 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1914 PyObject* o2;
1915 PyObject* o3;
1916
1917 if (!target) {
1918 target = o;
1919 } else if (target == Py_None) {
1920 Py_DECREF(Py_None);
1921 target = o;
1922 } else {
1923 if (!PyTuple_Check(target)) {
1924 o2 = target;
1925 target = PyTuple_New(1);
1926 PyTuple_SetItem(target, 0, o2);
1927 }
1928 o3 = PyTuple_New(1);
1929 PyTuple_SetItem(o3, 0, o);
1930
1931 o2 = target;
1932 target = PySequence_Concat(o2, o3);
1933 Py_DECREF(o2);
1934 Py_DECREF(o3);
1935 }
1936 return target;
1937 }
1938
1939
1940 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1941 self->m_x = x;
1942 self->m_y = y;
1943 }
1944 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1945 bool blocked = wxPyBeginBlockThreads();
1946 PyObject* tup = PyTuple_New(2);
1947 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1948 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1949 wxPyEndBlockThreads(blocked);
1950 return tup;
1951 }
1952
1953 #include "wx/wxPython/pyistream.h"
1954
1955 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1956 wxInputStream* wxis = wxPyCBInputStream::create(p);
1957 if (wxis)
1958 return new wxPyInputStream(wxis);
1959 else
1960 return NULL;
1961 }
1962
1963 SWIGINTERNSHORT PyObject*
1964 SWIG_From_char(char c)
1965 {
1966 return PyString_FromStringAndSize(&c,1);
1967 }
1968
1969
1970 SWIGINTERNSHORT PyObject*
1971 SWIG_From_unsigned_SS_long(unsigned long value)
1972 {
1973 return (value > LONG_MAX) ?
1974 PyLong_FromUnsignedLong(value)
1975 : PyInt_FromLong((long)(value));
1976 }
1977
1978
1979 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1980 SWIGINTERN int
1981 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1982 {
1983 static swig_type_info* pchar_info = 0;
1984 char* vptr = 0;
1985 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1986 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1987 if (cptr) *cptr = vptr;
1988 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1989 return SWIG_OLDOBJ;
1990 } else {
1991 PyErr_Clear();
1992 if (PyString_Check(obj)) {
1993 if (cptr) {
1994 *cptr = PyString_AS_STRING(obj);
1995 if (psize) {
1996 *psize = PyString_GET_SIZE(obj) + 1;
1997 }
1998 }
1999 return SWIG_PYSTR;
2000 }
2001 }
2002 if (cptr) {
2003 SWIG_type_error("char *", obj);
2004 }
2005 return 0;
2006 }
2007
2008
2009 SWIGINTERN int
2010 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2011 {
2012 char* cptr; size_t csize;
2013 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2014 /* in C you can do:
2015
2016 char x[5] = "hello";
2017
2018 ie, assing the array using an extra '0' char.
2019 */
2020 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2021 if (csize <= size) {
2022 if (val) {
2023 if (csize) memcpy(val, cptr, csize);
2024 if (csize < size) memset(val + csize, 0, size - csize);
2025 }
2026 return 1;
2027 }
2028 }
2029 if (val) {
2030 PyErr_Format(PyExc_TypeError,
2031 "a char array of maximum size %lu is expected",
2032 (unsigned long) size);
2033 }
2034 return 0;
2035 }
2036
2037
2038 SWIGINTERN int
2039 SWIG_AsVal_char(PyObject *obj, char *val)
2040 {
2041 const char* errmsg = val ? "char" : (char*)0;
2042 long v;
2043 if (SWIG_AsVal_long(obj, &v)) {
2044 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2045 if (val) *val = (char)(v);
2046 return 1;
2047 } else {
2048 return 0;
2049 }
2050 } else {
2051 PyErr_Clear();
2052 return SWIG_AsCharArray(obj, val, 1);
2053 }
2054 }
2055
2056
2057 SWIGINTERNSHORT char
2058 SWIG_As_char(PyObject* obj)
2059 {
2060 char v;
2061 if (!SWIG_AsVal_char(obj, &v)) {
2062 /*
2063 this is needed to make valgrind/purify happier.
2064 */
2065 memset((void*)&v, 0, sizeof(char));
2066 }
2067 return v;
2068 }
2069
2070
2071 SWIGINTERNSHORT int
2072 SWIG_Check_char(PyObject* obj)
2073 {
2074 return SWIG_AsVal_char(obj, (char*)0);
2075 }
2076
2077
2078 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2079 #define SWIG_From_long PyInt_FromLong
2080 /*@@*/
2081
2082 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2083 // We use only strings for the streams, not unicode
2084 PyObject* str = PyObject_Str(obj);
2085 if (! str) {
2086 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2087 return;
2088 }
2089 self->Write(PyString_AS_STRING(str),
2090 PyString_GET_SIZE(str));
2091 Py_DECREF(str);
2092 }
2093
2094 #include "wx/wxPython/pyistream.h"
2095
2096
2097 class wxPyFileSystemHandler : public wxFileSystemHandler
2098 {
2099 public:
2100 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2101
2102 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2103 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2104 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2105 DEC_PYCALLBACK_STRING__pure(FindNext);
2106
2107 wxString GetProtocol(const wxString& location) {
2108 return wxFileSystemHandler::GetProtocol(location);
2109 }
2110
2111 wxString GetLeftLocation(const wxString& location) {
2112 return wxFileSystemHandler::GetLeftLocation(location);
2113 }
2114
2115 wxString GetAnchor(const wxString& location) {
2116 return wxFileSystemHandler::GetAnchor(location);
2117 }
2118
2119 wxString GetRightLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetRightLocation(location);
2121 }
2122
2123 wxString GetMimeTypeFromExt(const wxString& location) {
2124 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2125 }
2126
2127 PYPRIVATE;
2128 };
2129
2130
2131 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2132 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2133 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2134 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2135
2136
2137 SWIGINTERN int
2138 SWIG_AsVal_bool(PyObject *obj, bool *val)
2139 {
2140 if (obj == Py_True) {
2141 if (val) *val = true;
2142 return 1;
2143 }
2144 if (obj == Py_False) {
2145 if (val) *val = false;
2146 return 1;
2147 }
2148 int res = 0;
2149 if (SWIG_AsVal_int(obj, &res)) {
2150 if (val) *val = res ? true : false;
2151 return 1;
2152 } else {
2153 PyErr_Clear();
2154 }
2155 if (val) {
2156 SWIG_type_error("bool", obj);
2157 }
2158 return 0;
2159 }
2160
2161
2162 SWIGINTERNSHORT bool
2163 SWIG_As_bool(PyObject* obj)
2164 {
2165 bool v;
2166 if (!SWIG_AsVal_bool(obj, &v)) {
2167 /*
2168 this is needed to make valgrind/purify happier.
2169 */
2170 memset((void*)&v, 0, sizeof(bool));
2171 }
2172 return v;
2173 }
2174
2175
2176 SWIGINTERNSHORT int
2177 SWIG_Check_bool(PyObject* obj)
2178 {
2179 return SWIG_AsVal_bool(obj, (bool*)0);
2180 }
2181
2182 static wxString FileSystem_URLToFileName(wxString const &url){
2183 wxFileName fname = wxFileSystem::URLToFileName(url);
2184 return fname.GetFullPath();
2185 }
2186
2187 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2188 wxImage& image,
2189 long type) {
2190 wxMemoryFSHandler::AddFile(filename, image, type);
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2194 const wxBitmap& bitmap,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2200 PyObject* data) {
2201 if (! PyString_Check(data)) {
2202 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2203 "Expected string object"));
2204 return;
2205 }
2206
2207 bool blocked = wxPyBeginBlockThreads();
2208 void* ptr = (void*)PyString_AsString(data);
2209 size_t size = PyString_Size(data);
2210 wxPyEndBlockThreads(blocked);
2211
2212 wxMemoryFSHandler::AddFile(filename, ptr, size);
2213 }
2214
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 SWIGINTERN int
2220 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2221 {
2222 long v = 0;
2223 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2224 SWIG_type_error("unsigned number", obj);
2225 }
2226 else if (val)
2227 *val = (unsigned long)v;
2228 return 1;
2229 }
2230
2231
2232 SWIGINTERNSHORT int
2233 SWIG_CheckUnsignedLongInRange(unsigned long value,
2234 unsigned long max_value,
2235 const char *errmsg)
2236 {
2237 if (value > max_value) {
2238 if (errmsg) {
2239 PyErr_Format(PyExc_OverflowError,
2240 "value %lu is greater than '%s' minimum %lu",
2241 value, errmsg, max_value);
2242 }
2243 return 0;
2244 }
2245 return 1;
2246 }
2247
2248
2249 SWIGINTERN int
2250 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2251 {
2252 const char* errmsg = val ? "unsigned char" : (char*)0;
2253 unsigned long v;
2254 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2255 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2256 if (val) *val = (unsigned char)(v);
2257 return 1;
2258 } else {
2259 return 0;
2260 }
2261 } else {
2262 PyErr_Clear();
2263 }
2264 if (val) {
2265 SWIG_type_error(errmsg, obj);
2266 }
2267 return 0;
2268 }
2269
2270
2271 SWIGINTERNSHORT unsigned char
2272 SWIG_As_unsigned_SS_char(PyObject* obj)
2273 {
2274 unsigned char v;
2275 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2276 /*
2277 this is needed to make valgrind/purify happier.
2278 */
2279 memset((void*)&v, 0, sizeof(unsigned char));
2280 }
2281 return v;
2282 }
2283
2284
2285 SWIGINTERNSHORT int
2286 SWIG_Check_unsigned_SS_char(PyObject* obj)
2287 {
2288 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2289 }
2290
2291
2292 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2293 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2294 /*@@*/
2295
2296
2297 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2298 if (width > 0 && height > 0)
2299 return new wxImage(width, height, clear);
2300 else
2301 return new wxImage;
2302 }
2303 static wxImage *new_wxImage(wxBitmap const &bitmap){
2304 return new wxImage(bitmap.ConvertToImage());
2305 }
2306 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2307 // Copy the source data so the wxImage can clean it up later
2308 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2309 if (copy == NULL) {
2310 PyErr_NoMemory();
2311 return NULL;
2312 }
2313 memcpy(copy, data, width*height*3);
2314 return new wxImage(width, height, copy, false);
2315 }
2316 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2317 // Copy the source data so the wxImage can clean it up later
2318 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2319 if (dcopy == NULL) {
2320 PyErr_NoMemory();
2321 return NULL;
2322 }
2323 memcpy(dcopy, data, width*height*3);
2324 unsigned char* acopy = (unsigned char*)malloc(width*height);
2325 if (acopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(acopy, alpha, width*height);
2330
2331 return new wxImage(width, height, dcopy, acopy, false);
2332 }
2333 static wxSize wxImage_GetSize(wxImage *self){
2334 wxSize size(self->GetWidth(), self->GetHeight());
2335 return size;
2336 }
2337 static PyObject *wxImage_GetData(wxImage *self){
2338 unsigned char* data = self->GetData();
2339 int len = self->GetWidth() * self->GetHeight() * 3;
2340 PyObject* rv;
2341 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2342 return rv;
2343 }
2344 static void wxImage_SetData(wxImage *self,PyObject *data){
2345 unsigned char* dataPtr;
2346
2347 if (! PyString_Check(data)) {
2348 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2349 "Expected string object"));
2350 return /* NULL */ ;
2351 }
2352
2353 size_t len = self->GetWidth() * self->GetHeight() * 3;
2354 dataPtr = (unsigned char*) malloc(len);
2355 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2356 self->SetData(dataPtr);
2357 // wxImage takes ownership of dataPtr...
2358 }
2359 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2360 unsigned char* data = self->GetData();
2361 int len = self->GetWidth() * self->GetHeight() * 3;
2362 PyObject* rv;
2363 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2364 return rv;
2365 }
2366 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2367 unsigned char* buffer;
2368 int size;
2369
2370 bool blocked = wxPyBeginBlockThreads();
2371 if (!PyArg_Parse(data, "t#", &buffer, &size))
2372 goto done;
2373
2374 if (size != self->GetWidth() * self->GetHeight() * 3) {
2375 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2376 goto done;
2377 }
2378 self->SetData(buffer);
2379 done:
2380 wxPyEndBlockThreads(blocked);
2381 }
2382 static PyObject *wxImage_GetAlphaData(wxImage *self){
2383 unsigned char* data = self->GetAlpha();
2384 if (! data) {
2385 RETURN_NONE();
2386 } else {
2387 int len = self->GetWidth() * self->GetHeight();
2388 PyObject* rv;
2389 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2390 return rv;
2391 }
2392 }
2393 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2394 unsigned char* dataPtr;
2395
2396 if (! PyString_Check(data)) {
2397 PyErr_SetString(PyExc_TypeError, "Expected string object");
2398 return /* NULL */ ;
2399 }
2400
2401 size_t len = self->GetWidth() * self->GetHeight();
2402 dataPtr = (unsigned char*) malloc(len);
2403 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2404 self->SetAlpha(dataPtr);
2405 // wxImage takes ownership of dataPtr...
2406 }
2407 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2408 unsigned char* data = self->GetAlpha();
2409 int len = self->GetWidth() * self->GetHeight();
2410 PyObject* rv;
2411 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2412 return rv;
2413 }
2414 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2415 unsigned char* buffer;
2416 int size;
2417
2418 bool blocked = wxPyBeginBlockThreads();
2419 if (!PyArg_Parse(data, "t#", &buffer, &size))
2420 goto done;
2421
2422 if (size != self->GetWidth() * self->GetHeight()) {
2423 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2424 goto done;
2425 }
2426 self->SetAlpha(buffer);
2427 done:
2428 wxPyEndBlockThreads(blocked);
2429 }
2430
2431 SWIGINTERNSHORT unsigned long
2432 SWIG_As_unsigned_SS_long(PyObject* obj)
2433 {
2434 unsigned long v;
2435 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2436 /*
2437 this is needed to make valgrind/purify happier.
2438 */
2439 memset((void*)&v, 0, sizeof(unsigned long));
2440 }
2441 return v;
2442 }
2443
2444
2445 SWIGINTERNSHORT int
2446 SWIG_Check_unsigned_SS_long(PyObject* obj)
2447 {
2448 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2449 }
2450
2451 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2452 wxBitmap bitmap(*self, depth);
2453 return bitmap;
2454 }
2455 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2456 wxImage mono = self->ConvertToMono( red, green, blue );
2457 wxBitmap bitmap( mono, 1 );
2458 return bitmap;
2459 }
2460 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2461 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2462 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2463 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2464 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2465
2466 #include <wx/quantize.h>
2467
2468 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2469 return wxQuantize::Quantize(src, dest,
2470 //NULL, // palette
2471 desiredNoColours,
2472 NULL, // eightBitData
2473 flags);
2474 }
2475 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2476 if (PyCallable_Check(func)) {
2477 self->Connect(id, lastId, eventType,
2478 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2479 new wxPyCallback(func));
2480 }
2481 else if (func == Py_None) {
2482 self->Disconnect(id, lastId, eventType,
2483 (wxObjectEventFunction)
2484 &wxPyCallback::EventThunker);
2485 }
2486 else {
2487 wxPyBLOCK_THREADS(
2488 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2489 }
2490 }
2491 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2492 return self->Disconnect(id, lastId, eventType,
2493 (wxObjectEventFunction)
2494 &wxPyCallback::EventThunker);
2495 }
2496 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2497 if (_self && _self != Py_None) {
2498 self->SetClientObject(new wxPyOORClientData(_self, incref));
2499 }
2500 else {
2501 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2502 if (data) {
2503 self->SetClientObject(NULL); // This will delete it too
2504 }
2505 }
2506 }
2507
2508 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2509 #if wxUSE_UNICODE
2510 return self->GetUnicodeKey();
2511 #else
2512 return 0;
2513 #endif
2514 }
2515
2516 #if UINT_MAX < LONG_MAX
2517 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2518 #define SWIG_From_unsigned_SS_int SWIG_From_long
2519 /*@@*/
2520 #else
2521 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2522 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2523 /*@@*/
2524 #endif
2525
2526
2527 #if UINT_MAX != ULONG_MAX
2528 SWIGINTERN int
2529 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2530 {
2531 const char* errmsg = val ? "unsigned int" : (char*)0;
2532 unsigned long v;
2533 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2534 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2535 if (val) *val = (unsigned int)(v);
2536 return 1;
2537 }
2538 } else {
2539 PyErr_Clear();
2540 }
2541 if (val) {
2542 SWIG_type_error(errmsg, obj);
2543 }
2544 return 0;
2545 }
2546 #else
2547 SWIGINTERNSHORT unsigned int
2548 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2549 {
2550 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2551 }
2552 #endif
2553
2554
2555 SWIGINTERNSHORT unsigned int
2556 SWIG_As_unsigned_SS_int(PyObject* obj)
2557 {
2558 unsigned int v;
2559 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2560 /*
2561 this is needed to make valgrind/purify happier.
2562 */
2563 memset((void*)&v, 0, sizeof(unsigned int));
2564 }
2565 return v;
2566 }
2567
2568
2569 SWIGINTERNSHORT int
2570 SWIG_Check_unsigned_SS_int(PyObject* obj)
2571 {
2572 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2573 }
2574
2575 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2576 self->m_size = size;
2577 }
2578 static void wxMoveEvent_SetPosition(wxMoveEvent *self,wxPoint pos){
2579 self->m_pos = pos;
2580 }
2581 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2582 int count = self->GetNumberOfFiles();
2583 wxString* files = self->GetFiles();
2584 PyObject* list = PyList_New(count);
2585
2586 if (!list) {
2587 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2588 return NULL;
2589 }
2590
2591 for (int i=0; i<count; i++) {
2592 PyList_SetItem(list, i, wx2PyString(files[i]));
2593 }
2594 return list;
2595 }
2596
2597
2598 static wxPyApp *new_wxPyApp(){
2599 wxPythonApp = new wxPyApp();
2600 return wxPythonApp;
2601 }
2602 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2603
2604 void wxApp_CleanUp() {
2605 __wxPyCleanup();
2606 }
2607
2608
2609 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2610
2611
2612 SWIGINTERNSHORT int
2613 SWIG_AsCharPtr(PyObject *obj, char **val)
2614 {
2615 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2616 return 1;
2617 }
2618 if (val) {
2619 PyErr_Clear();
2620 SWIG_type_error("char *", obj);
2621 }
2622 return 0;
2623 }
2624
2625
2626 SWIGINTERN PyObject *
2627 SWIG_FromCharPtr(const char* cptr)
2628 {
2629 if (cptr) {
2630 size_t size = strlen(cptr);
2631 if (size > INT_MAX) {
2632 return SWIG_NewPointerObj((char*)(cptr),
2633 SWIG_TypeQuery("char *"), 0);
2634 } else {
2635 if (size != 0) {
2636 return PyString_FromStringAndSize(cptr, size);
2637 } else {
2638 return PyString_FromString(cptr);
2639 }
2640 }
2641 }
2642 Py_INCREF(Py_None);
2643 return Py_None;
2644 }
2645
2646
2647 #ifdef __WXMAC__
2648
2649 // A dummy class that raises an exception if used...
2650 class wxEventLoop
2651 {
2652 public:
2653 wxEventLoop() { wxPyRaiseNotImplemented(); }
2654 int Run() { return 0; }
2655 void Exit(int rc = 0) {}
2656 bool Pending() const { return false; }
2657 bool Dispatch() { return false; }
2658 bool IsRunning() const { return false; }
2659 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2660 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2661 };
2662
2663 #else
2664
2665 #include <wx/evtloop.h>
2666
2667 #endif
2668
2669
2670
2671 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2672 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2673 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2674 static PyObject *wxWindow_GetChildren(wxWindow *self){
2675 wxWindowList& list = self->GetChildren();
2676 return wxPy_ConvertList(&list);
2677 }
2678 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2679 #if wxUSE_HOTKEY
2680 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2681 #else
2682 return false;
2683 #endif
2684 }
2685 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2686
2687
2688
2689 return false;
2690
2691 }
2692 static long wxWindow_GetHandle(wxWindow *self){
2693 return wxPyGetWinHandle(self);
2694 }
2695 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2696 self->AssociateHandle((WXWidget)handle);
2697 }
2698
2699 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2700 return wxWindow::FindWindowById(id, parent);
2701 }
2702
2703 wxWindow* wxFindWindowByName( const wxString& name,
2704 const wxWindow *parent = NULL ) {
2705 return wxWindow::FindWindowByName(name, parent);
2706 }
2707
2708 wxWindow* wxFindWindowByLabel( const wxString& label,
2709 const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowByLabel(label, parent);
2711 }
2712
2713
2714 #ifdef __WXMSW__
2715 #include <wx/msw/private.h> // to get wxGetWindowId
2716 #endif
2717
2718
2719 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2720 #ifdef __WXMSW__
2721 WXHWND hWnd = (WXHWND)_hWnd;
2722 long id = wxGetWindowId(hWnd);
2723 wxWindow* win = new wxWindow;
2724 parent->AddChild(win);
2725 win->SetEventHandler(win);
2726 win->SetHWND(hWnd);
2727 win->SetId(id);
2728 win->SubclassWin(hWnd);
2729 win->AdoptAttributesFromHWND();
2730 win->SetupColours();
2731 return win;
2732 #else
2733 wxPyRaiseNotImplemented();
2734 return NULL;
2735 #endif
2736 }
2737
2738
2739 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2740 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2741 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2742
2743 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2744
2745 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2746 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2747 wxMenuItemList& list = self->GetMenuItems();
2748 return wxPy_ConvertList(&list);
2749 }
2750 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2751 static const wxString wxPyControlNameStr(wxControlNameStr);
2752 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2753 if (clientData) {
2754 wxPyClientData* data = new wxPyClientData(clientData);
2755 return self->Append(item, data);
2756 } else
2757 return self->Append(item);
2758 }
2759 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2760 if (clientData) {
2761 wxPyClientData* data = new wxPyClientData(clientData);
2762 return self->Insert(item, pos, data);
2763 } else
2764 return self->Insert(item, pos);
2765 }
2766 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2767 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2768 if (data) {
2769 Py_INCREF(data->m_obj);
2770 return data->m_obj;
2771 } else {
2772 Py_INCREF(Py_None);
2773 return Py_None;
2774 }
2775 }
2776 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2777 wxPyClientData* data = new wxPyClientData(clientData);
2778 self->SetClientObject(n, data);
2779 }
2780
2781
2782 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2783 wxPyUserData* data = NULL;
2784 if ( userData ) {
2785 bool blocked = wxPyBeginBlockThreads();
2786 data = new wxPyUserData(userData);
2787 wxPyEndBlockThreads(blocked);
2788 }
2789 return new wxSizerItem(window, proportion, flag, border, data);
2790 }
2791 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2792 wxPyUserData* data = NULL;
2793 if ( userData ) {
2794 bool blocked = wxPyBeginBlockThreads();
2795 data = new wxPyUserData(userData);
2796 wxPyEndBlockThreads(blocked);
2797 }
2798 return new wxSizerItem(width, height, proportion, flag, border, data);
2799 }
2800 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2801 wxPyUserData* data = NULL;
2802 if ( userData ) {
2803 bool blocked = wxPyBeginBlockThreads();
2804 data = new wxPyUserData(userData);
2805 wxPyEndBlockThreads(blocked);
2806 }
2807 return new wxSizerItem(sizer, proportion, flag, border, data);
2808 }
2809
2810 #include <float.h>
2811 SWIGINTERN int
2812 SWIG_CheckDoubleInRange(double value, double min_value,
2813 double max_value, const char* errmsg)
2814 {
2815 if (value < min_value) {
2816 if (errmsg) {
2817 PyErr_Format(PyExc_OverflowError,
2818 "value %g is less than %s minimum %g",
2819 value, errmsg, min_value);
2820 }
2821 return 0;
2822 } else if (value > max_value) {
2823 if (errmsg) {
2824 PyErr_Format(PyExc_OverflowError,
2825 "value %g is greater than %s maximum %g",
2826 value, errmsg, max_value);
2827 }
2828 return 0;
2829 }
2830 return 1;
2831 }
2832
2833
2834 SWIGINTERN int
2835 SWIG_AsVal_float(PyObject *obj, float *val)
2836 {
2837 const char* errmsg = val ? "float" : (char*)0;
2838 double v;
2839 if (SWIG_AsVal_double(obj, &v)) {
2840 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2841 if (val) *val = (float)(v);
2842 return 1;
2843 } else {
2844 return 0;
2845 }
2846 } else {
2847 PyErr_Clear();
2848 }
2849 if (val) {
2850 SWIG_type_error(errmsg, obj);
2851 }
2852 return 0;
2853 }
2854
2855
2856 SWIGINTERNSHORT float
2857 SWIG_As_float(PyObject* obj)
2858 {
2859 float v;
2860 if (!SWIG_AsVal_float(obj, &v)) {
2861 /*
2862 this is needed to make valgrind/purify happier.
2863 */
2864 memset((void*)&v, 0, sizeof(float));
2865 }
2866 return v;
2867 }
2868
2869
2870 SWIGINTERNSHORT int
2871 SWIG_Check_float(PyObject* obj)
2872 {
2873 return SWIG_AsVal_float(obj, (float*)0);
2874 }
2875
2876
2877 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2878 #define SWIG_From_float PyFloat_FromDouble
2879 /*@@*/
2880
2881 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2882 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2883 if (data) {
2884 Py_INCREF(data->m_obj);
2885 return data->m_obj;
2886 } else {
2887 Py_INCREF(Py_None);
2888 return Py_None;
2889 }
2890 }
2891
2892 // Figure out the type of the sizer item
2893
2894 struct wxPySizerItemInfo {
2895 wxPySizerItemInfo()
2896 : window(NULL), sizer(NULL), gotSize(false),
2897 size(wxDefaultSize), gotPos(false), pos(-1)
2898 {}
2899
2900 wxWindow* window;
2901 wxSizer* sizer;
2902 bool gotSize;
2903 wxSize size;
2904 bool gotPos;
2905 int pos;
2906 };
2907
2908 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2909
2910 wxPySizerItemInfo info;
2911 wxSize size;
2912 wxSize* sizePtr = &size;
2913
2914 // Find out what the type of the item is
2915 // try wxWindow
2916 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2917 PyErr_Clear();
2918 info.window = NULL;
2919
2920 // try wxSizer
2921 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2922 PyErr_Clear();
2923 info.sizer = NULL;
2924
2925 // try wxSize or (w,h)
2926 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2927 info.size = *sizePtr;
2928 info.gotSize = true;
2929 }
2930
2931 // or a single int
2932 if (checkIdx && PyInt_Check(item)) {
2933 info.pos = PyInt_AsLong(item);
2934 info.gotPos = true;
2935 }
2936 }
2937 }
2938
2939 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2940 // no expected type, figure out what kind of error message to generate
2941 if ( !checkSize && !checkIdx )
2942 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2943 else if ( checkSize && !checkIdx )
2944 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2945 else if ( !checkSize && checkIdx)
2946 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2947 else
2948 // can this one happen?
2949 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2950 }
2951
2952 return info;
2953 }
2954
2955 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2956 if (!self->GetClientObject())
2957 self->SetClientObject(new wxPyOORClientData(_self));
2958 }
2959 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2960
2961 wxPyUserData* data = NULL;
2962 bool blocked = wxPyBeginBlockThreads();
2963 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2964 if ( userData && (info.window || info.sizer || info.gotSize) )
2965 data = new wxPyUserData(userData);
2966 wxPyEndBlockThreads(blocked);
2967
2968 // Now call the real Add method if a valid item type was found
2969 if ( info.window )
2970 return self->Add(info.window, proportion, flag, border, data);
2971 else if ( info.sizer )
2972 return self->Add(info.sizer, proportion, flag, border, data);
2973 else if (info.gotSize)
2974 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2975 proportion, flag, border, data);
2976 else
2977 return NULL;
2978 }
2979 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2980
2981 wxPyUserData* data = NULL;
2982 bool blocked = wxPyBeginBlockThreads();
2983 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2984 if ( userData && (info.window || info.sizer || info.gotSize) )
2985 data = new wxPyUserData(userData);
2986 wxPyEndBlockThreads(blocked);
2987
2988 // Now call the real Insert method if a valid item type was found
2989 if ( info.window )
2990 return self->Insert(before, info.window, proportion, flag, border, data);
2991 else if ( info.sizer )
2992 return self->Insert(before, info.sizer, proportion, flag, border, data);
2993 else if (info.gotSize)
2994 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2995 proportion, flag, border, data);
2996 else
2997 return NULL;
2998 }
2999 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3000
3001 wxPyUserData* data = NULL;
3002 bool blocked = wxPyBeginBlockThreads();
3003 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3004 if ( userData && (info.window || info.sizer || info.gotSize) )
3005 data = new wxPyUserData(userData);
3006 wxPyEndBlockThreads(blocked);
3007
3008 // Now call the real Prepend method if a valid item type was found
3009 if ( info.window )
3010 return self->Prepend(info.window, proportion, flag, border, data);
3011 else if ( info.sizer )
3012 return self->Prepend(info.sizer, proportion, flag, border, data);
3013 else if (info.gotSize)
3014 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3015 proportion, flag, border, data);
3016 else
3017 return NULL;
3018 }
3019 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3020 bool blocked = wxPyBeginBlockThreads();
3021 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3022 wxPyEndBlockThreads(blocked);
3023 if ( info.window )
3024 return self->Remove(info.window);
3025 else if ( info.sizer )
3026 return self->Remove(info.sizer);
3027 else if ( info.gotPos )
3028 return self->Remove(info.pos);
3029 else
3030 return false;
3031 }
3032 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3033 bool blocked = wxPyBeginBlockThreads();
3034 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3035 wxPyEndBlockThreads(blocked);
3036 if ( info.window )
3037 return self->Detach(info.window);
3038 else if ( info.sizer )
3039 return self->Detach(info.sizer);
3040 else if ( info.gotPos )
3041 return self->Detach(info.pos);
3042 else
3043 return false;
3044 }
3045 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3046 bool blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3048 wxPyEndBlockThreads(blocked);
3049 if ( info.window )
3050 return self->GetItem(info.window);
3051 else if ( info.sizer )
3052 return self->GetItem(info.sizer);
3053 else if ( info.gotPos )
3054 return self->GetItem(info.pos);
3055 else
3056 return NULL;
3057 }
3058 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3059 bool blocked = wxPyBeginBlockThreads();
3060 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3061 wxPyEndBlockThreads(blocked);
3062 if ( info.window )
3063 self->SetItemMinSize(info.window, size);
3064 else if ( info.sizer )
3065 self->SetItemMinSize(info.sizer, size);
3066 else if ( info.gotPos )
3067 self->SetItemMinSize(info.pos, size);
3068 }
3069 static PyObject *wxSizer_GetChildren(wxSizer *self){
3070 wxSizerItemList& list = self->GetChildren();
3071 return wxPy_ConvertList(&list);
3072 }
3073 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3074 bool blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->Show(info.window, show, recursive);
3079 else if ( info.sizer )
3080 return self->Show(info.sizer, show, recursive);
3081 else if ( info.gotPos )
3082 return self->Show(info.pos, show);
3083 else
3084 return false;
3085 }
3086 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3087 bool blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->IsShown(info.window);
3092 else if ( info.sizer )
3093 return self->IsShown(info.sizer);
3094 else if ( info.gotPos )
3095 return self->IsShown(info.pos);
3096 else
3097 return false;
3098 }
3099
3100 // See pyclasses.h
3101 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3102 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3103 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3104
3105
3106
3107
3108 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3109 {
3110 if (source == Py_None) {
3111 **obj = wxGBPosition(-1,-1);
3112 return true;
3113 }
3114 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3115 }
3116
3117 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3118 {
3119 if (source == Py_None) {
3120 **obj = wxGBSpan(-1,-1);
3121 return true;
3122 }
3123 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3124 }
3125
3126
3127 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3128 self->SetRow(row);
3129 self->SetCol(col);
3130 }
3131 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3132 bool blocked = wxPyBeginBlockThreads();
3133 PyObject* tup = PyTuple_New(2);
3134 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3135 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3136 wxPyEndBlockThreads(blocked);
3137 return tup;
3138 }
3139 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3140 self->SetRowspan(rowspan);
3141 self->SetColspan(colspan);
3142 }
3143 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3144 bool blocked = wxPyBeginBlockThreads();
3145 PyObject* tup = PyTuple_New(2);
3146 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3147 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3148 wxPyEndBlockThreads(blocked);
3149 return tup;
3150 }
3151 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3152 wxPyUserData* data = NULL;
3153 if ( userData ) {
3154 bool blocked = wxPyBeginBlockThreads();
3155 data = new wxPyUserData(userData);
3156 wxPyEndBlockThreads(blocked);
3157 }
3158 return new wxGBSizerItem(window, pos, span, flag, border, data);
3159 }
3160 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3161 wxPyUserData* data = NULL;
3162 if ( userData ) {
3163 bool blocked = wxPyBeginBlockThreads();
3164 data = new wxPyUserData(userData);
3165 wxPyEndBlockThreads(blocked);
3166 }
3167 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3168 }
3169 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3170 wxPyUserData* data = NULL;
3171 if ( userData ) {
3172 bool blocked = wxPyBeginBlockThreads();
3173 data = new wxPyUserData(userData);
3174 wxPyEndBlockThreads(blocked);
3175 }
3176 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3177 }
3178 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3179 int row, col;
3180 self->GetEndPos(row, col);
3181 return wxGBPosition(row, col);
3182 }
3183 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3184
3185 wxPyUserData* data = NULL;
3186 bool blocked = wxPyBeginBlockThreads();
3187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3188 if ( userData && (info.window || info.sizer || info.gotSize) )
3189 data = new wxPyUserData(userData);
3190 wxPyEndBlockThreads(blocked);
3191
3192 // Now call the real Add method if a valid item type was found
3193 if ( info.window )
3194 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3195 else if ( info.sizer )
3196 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3197 else if (info.gotSize)
3198 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3199 pos, span, flag, border, data);
3200 return NULL;
3201 }
3202
3203
3204 #ifdef __cplusplus
3205 extern "C" {
3206 #endif
3207 static int _wrap_EmptyString_set(PyObject *) {
3208 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3209 return 1;
3210 }
3211
3212
3213 static PyObject *_wrap_EmptyString_get(void) {
3214 PyObject *pyobj;
3215
3216 {
3217 #if wxUSE_UNICODE
3218 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3219 #else
3220 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3221 #endif
3222 }
3223 return pyobj;
3224 }
3225
3226
3227 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3228 PyObject *resultobj;
3229 wxObject *arg1 = (wxObject *) 0 ;
3230 wxString result;
3231 PyObject * obj0 = 0 ;
3232 char *kwnames[] = {
3233 (char *) "self", NULL
3234 };
3235
3236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3238 if (SWIG_arg_fail(1)) SWIG_fail;
3239 {
3240 PyThreadState* __tstate = wxPyBeginAllowThreads();
3241 result = wxObject_GetClassName(arg1);
3242
3243 wxPyEndAllowThreads(__tstate);
3244 if (PyErr_Occurred()) SWIG_fail;
3245 }
3246 {
3247 #if wxUSE_UNICODE
3248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3249 #else
3250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3251 #endif
3252 }
3253 return resultobj;
3254 fail:
3255 return NULL;
3256 }
3257
3258
3259 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3260 PyObject *resultobj;
3261 wxObject *arg1 = (wxObject *) 0 ;
3262 PyObject * obj0 = 0 ;
3263 char *kwnames[] = {
3264 (char *) "self", NULL
3265 };
3266
3267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3269 if (SWIG_arg_fail(1)) SWIG_fail;
3270 {
3271 PyThreadState* __tstate = wxPyBeginAllowThreads();
3272 wxObject_Destroy(arg1);
3273
3274 wxPyEndAllowThreads(__tstate);
3275 if (PyErr_Occurred()) SWIG_fail;
3276 }
3277 Py_INCREF(Py_None); resultobj = Py_None;
3278 return resultobj;
3279 fail:
3280 return NULL;
3281 }
3282
3283
3284 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3285 PyObject *obj;
3286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3287 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3288 Py_INCREF(obj);
3289 return Py_BuildValue((char *)"");
3290 }
3291 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3292 PyObject *resultobj;
3293 wxSize *arg1 = (wxSize *) 0 ;
3294 int arg2 ;
3295 PyObject * obj0 = 0 ;
3296 PyObject * obj1 = 0 ;
3297 char *kwnames[] = {
3298 (char *) "self",(char *) "x", NULL
3299 };
3300
3301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3303 if (SWIG_arg_fail(1)) SWIG_fail;
3304 {
3305 arg2 = (int)(SWIG_As_int(obj1));
3306 if (SWIG_arg_fail(2)) SWIG_fail;
3307 }
3308 if (arg1) (arg1)->x = arg2;
3309
3310 Py_INCREF(Py_None); resultobj = Py_None;
3311 return resultobj;
3312 fail:
3313 return NULL;
3314 }
3315
3316
3317 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3318 PyObject *resultobj;
3319 wxSize *arg1 = (wxSize *) 0 ;
3320 int result;
3321 PyObject * obj0 = 0 ;
3322 char *kwnames[] = {
3323 (char *) "self", NULL
3324 };
3325
3326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3328 if (SWIG_arg_fail(1)) SWIG_fail;
3329 result = (int) ((arg1)->x);
3330
3331 {
3332 resultobj = SWIG_From_int((int)(result));
3333 }
3334 return resultobj;
3335 fail:
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxSize *arg1 = (wxSize *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "y", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 if (arg1) (arg1)->y = arg2;
3358
3359 Py_INCREF(Py_None); resultobj = Py_None;
3360 return resultobj;
3361 fail:
3362 return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3367 PyObject *resultobj;
3368 wxSize *arg1 = (wxSize *) 0 ;
3369 int result;
3370 PyObject * obj0 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "self", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3377 if (SWIG_arg_fail(1)) SWIG_fail;
3378 result = (int) ((arg1)->y);
3379
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 return resultobj;
3384 fail:
3385 return NULL;
3386 }
3387
3388
3389 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj;
3391 int arg1 = (int) 0 ;
3392 int arg2 = (int) 0 ;
3393 wxSize *result;
3394 PyObject * obj0 = 0 ;
3395 PyObject * obj1 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "w",(char *) "h", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3401 if (obj0) {
3402 {
3403 arg1 = (int)(SWIG_As_int(obj0));
3404 if (SWIG_arg_fail(1)) SWIG_fail;
3405 }
3406 }
3407 if (obj1) {
3408 {
3409 arg2 = (int)(SWIG_As_int(obj1));
3410 if (SWIG_arg_fail(2)) SWIG_fail;
3411 }
3412 }
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 result = (wxSize *)new wxSize(arg1,arg2);
3416
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3421 return resultobj;
3422 fail:
3423 return NULL;
3424 }
3425
3426
3427 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3428 PyObject *resultobj;
3429 wxSize *arg1 = (wxSize *) 0 ;
3430 PyObject * obj0 = 0 ;
3431 char *kwnames[] = {
3432 (char *) "self", NULL
3433 };
3434
3435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3437 if (SWIG_arg_fail(1)) SWIG_fail;
3438 {
3439 PyThreadState* __tstate = wxPyBeginAllowThreads();
3440 delete arg1;
3441
3442 wxPyEndAllowThreads(__tstate);
3443 if (PyErr_Occurred()) SWIG_fail;
3444 }
3445 Py_INCREF(Py_None); resultobj = Py_None;
3446 return resultobj;
3447 fail:
3448 return NULL;
3449 }
3450
3451
3452 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3453 PyObject *resultobj;
3454 wxSize *arg1 = (wxSize *) 0 ;
3455 wxSize *arg2 = 0 ;
3456 bool result;
3457 wxSize temp2 ;
3458 PyObject * obj0 = 0 ;
3459 PyObject * obj1 = 0 ;
3460 char *kwnames[] = {
3461 (char *) "self",(char *) "sz", NULL
3462 };
3463
3464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3466 if (SWIG_arg_fail(1)) SWIG_fail;
3467 {
3468 arg2 = &temp2;
3469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3470 }
3471 {
3472 PyThreadState* __tstate = wxPyBeginAllowThreads();
3473 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3474
3475 wxPyEndAllowThreads(__tstate);
3476 if (PyErr_Occurred()) SWIG_fail;
3477 }
3478 {
3479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3480 }
3481 return resultobj;
3482 fail:
3483 return NULL;
3484 }
3485
3486
3487 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3488 PyObject *resultobj;
3489 wxSize *arg1 = (wxSize *) 0 ;
3490 wxSize *arg2 = 0 ;
3491 bool result;
3492 wxSize temp2 ;
3493 PyObject * obj0 = 0 ;
3494 PyObject * obj1 = 0 ;
3495 char *kwnames[] = {
3496 (char *) "self",(char *) "sz", NULL
3497 };
3498
3499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3501 if (SWIG_arg_fail(1)) SWIG_fail;
3502 {
3503 arg2 = &temp2;
3504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3505 }
3506 {
3507 PyThreadState* __tstate = wxPyBeginAllowThreads();
3508 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3509
3510 wxPyEndAllowThreads(__tstate);
3511 if (PyErr_Occurred()) SWIG_fail;
3512 }
3513 {
3514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3515 }
3516 return resultobj;
3517 fail:
3518 return NULL;
3519 }
3520
3521
3522 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3523 PyObject *resultobj;
3524 wxSize *arg1 = (wxSize *) 0 ;
3525 wxSize *arg2 = 0 ;
3526 wxSize result;
3527 wxSize temp2 ;
3528 PyObject * obj0 = 0 ;
3529 PyObject * obj1 = 0 ;
3530 char *kwnames[] = {
3531 (char *) "self",(char *) "sz", NULL
3532 };
3533
3534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3536 if (SWIG_arg_fail(1)) SWIG_fail;
3537 {
3538 arg2 = &temp2;
3539 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3540 }
3541 {
3542 PyThreadState* __tstate = wxPyBeginAllowThreads();
3543 result = (arg1)->operator +((wxSize const &)*arg2);
3544
3545 wxPyEndAllowThreads(__tstate);
3546 if (PyErr_Occurred()) SWIG_fail;
3547 }
3548 {
3549 wxSize * resultptr;
3550 resultptr = new wxSize((wxSize &)(result));
3551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3552 }
3553 return resultobj;
3554 fail:
3555 return NULL;
3556 }
3557
3558
3559 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3560 PyObject *resultobj;
3561 wxSize *arg1 = (wxSize *) 0 ;
3562 wxSize *arg2 = 0 ;
3563 wxSize result;
3564 wxSize temp2 ;
3565 PyObject * obj0 = 0 ;
3566 PyObject * obj1 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "self",(char *) "sz", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 {
3575 arg2 = &temp2;
3576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3577 }
3578 {
3579 PyThreadState* __tstate = wxPyBeginAllowThreads();
3580 result = (arg1)->operator -((wxSize const &)*arg2);
3581
3582 wxPyEndAllowThreads(__tstate);
3583 if (PyErr_Occurred()) SWIG_fail;
3584 }
3585 {
3586 wxSize * resultptr;
3587 resultptr = new wxSize((wxSize &)(result));
3588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3589 }
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 wxSize *arg1 = (wxSize *) 0 ;
3599 wxSize *arg2 = 0 ;
3600 wxSize temp2 ;
3601 PyObject * obj0 = 0 ;
3602 PyObject * obj1 = 0 ;
3603 char *kwnames[] = {
3604 (char *) "self",(char *) "sz", NULL
3605 };
3606
3607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3609 if (SWIG_arg_fail(1)) SWIG_fail;
3610 {
3611 arg2 = &temp2;
3612 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3613 }
3614 {
3615 PyThreadState* __tstate = wxPyBeginAllowThreads();
3616 (arg1)->IncTo((wxSize const &)*arg2);
3617
3618 wxPyEndAllowThreads(__tstate);
3619 if (PyErr_Occurred()) SWIG_fail;
3620 }
3621 Py_INCREF(Py_None); resultobj = Py_None;
3622 return resultobj;
3623 fail:
3624 return NULL;
3625 }
3626
3627
3628 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3629 PyObject *resultobj;
3630 wxSize *arg1 = (wxSize *) 0 ;
3631 wxSize *arg2 = 0 ;
3632 wxSize temp2 ;
3633 PyObject * obj0 = 0 ;
3634 PyObject * obj1 = 0 ;
3635 char *kwnames[] = {
3636 (char *) "self",(char *) "sz", NULL
3637 };
3638
3639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3641 if (SWIG_arg_fail(1)) SWIG_fail;
3642 {
3643 arg2 = &temp2;
3644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3645 }
3646 {
3647 PyThreadState* __tstate = wxPyBeginAllowThreads();
3648 (arg1)->DecTo((wxSize const &)*arg2);
3649
3650 wxPyEndAllowThreads(__tstate);
3651 if (PyErr_Occurred()) SWIG_fail;
3652 }
3653 Py_INCREF(Py_None); resultobj = Py_None;
3654 return resultobj;
3655 fail:
3656 return NULL;
3657 }
3658
3659
3660 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3661 PyObject *resultobj;
3662 wxSize *arg1 = (wxSize *) 0 ;
3663 int arg2 ;
3664 int arg3 ;
3665 PyObject * obj0 = 0 ;
3666 PyObject * obj1 = 0 ;
3667 PyObject * obj2 = 0 ;
3668 char *kwnames[] = {
3669 (char *) "self",(char *) "w",(char *) "h", NULL
3670 };
3671
3672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3674 if (SWIG_arg_fail(1)) SWIG_fail;
3675 {
3676 arg2 = (int)(SWIG_As_int(obj1));
3677 if (SWIG_arg_fail(2)) SWIG_fail;
3678 }
3679 {
3680 arg3 = (int)(SWIG_As_int(obj2));
3681 if (SWIG_arg_fail(3)) SWIG_fail;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 (arg1)->Set(arg2,arg3);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 return resultobj;
3692 fail:
3693 return NULL;
3694 }
3695
3696
3697 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3698 PyObject *resultobj;
3699 wxSize *arg1 = (wxSize *) 0 ;
3700 int arg2 ;
3701 PyObject * obj0 = 0 ;
3702 PyObject * obj1 = 0 ;
3703 char *kwnames[] = {
3704 (char *) "self",(char *) "w", NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3709 if (SWIG_arg_fail(1)) SWIG_fail;
3710 {
3711 arg2 = (int)(SWIG_As_int(obj1));
3712 if (SWIG_arg_fail(2)) SWIG_fail;
3713 }
3714 {
3715 PyThreadState* __tstate = wxPyBeginAllowThreads();
3716 (arg1)->SetWidth(arg2);
3717
3718 wxPyEndAllowThreads(__tstate);
3719 if (PyErr_Occurred()) SWIG_fail;
3720 }
3721 Py_INCREF(Py_None); resultobj = Py_None;
3722 return resultobj;
3723 fail:
3724 return NULL;
3725 }
3726
3727
3728 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3729 PyObject *resultobj;
3730 wxSize *arg1 = (wxSize *) 0 ;
3731 int arg2 ;
3732 PyObject * obj0 = 0 ;
3733 PyObject * obj1 = 0 ;
3734 char *kwnames[] = {
3735 (char *) "self",(char *) "h", NULL
3736 };
3737
3738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3740 if (SWIG_arg_fail(1)) SWIG_fail;
3741 {
3742 arg2 = (int)(SWIG_As_int(obj1));
3743 if (SWIG_arg_fail(2)) SWIG_fail;
3744 }
3745 {
3746 PyThreadState* __tstate = wxPyBeginAllowThreads();
3747 (arg1)->SetHeight(arg2);
3748
3749 wxPyEndAllowThreads(__tstate);
3750 if (PyErr_Occurred()) SWIG_fail;
3751 }
3752 Py_INCREF(Py_None); resultobj = Py_None;
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 wxSize *arg1 = (wxSize *) 0 ;
3762 int result;
3763 PyObject * obj0 = 0 ;
3764 char *kwnames[] = {
3765 (char *) "self", NULL
3766 };
3767
3768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3770 if (SWIG_arg_fail(1)) SWIG_fail;
3771 {
3772 PyThreadState* __tstate = wxPyBeginAllowThreads();
3773 result = (int)((wxSize const *)arg1)->GetWidth();
3774
3775 wxPyEndAllowThreads(__tstate);
3776 if (PyErr_Occurred()) SWIG_fail;
3777 }
3778 {
3779 resultobj = SWIG_From_int((int)(result));
3780 }
3781 return resultobj;
3782 fail:
3783 return NULL;
3784 }
3785
3786
3787 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3788 PyObject *resultobj;
3789 wxSize *arg1 = (wxSize *) 0 ;
3790 int result;
3791 PyObject * obj0 = 0 ;
3792 char *kwnames[] = {
3793 (char *) "self", NULL
3794 };
3795
3796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3798 if (SWIG_arg_fail(1)) SWIG_fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (int)((wxSize const *)arg1)->GetHeight();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = SWIG_From_int((int)(result));
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 bool result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 wxSize *arg2 = 0 ;
3847 wxSize temp2 ;
3848 PyObject * obj0 = 0 ;
3849 PyObject * obj1 = 0 ;
3850 char *kwnames[] = {
3851 (char *) "self",(char *) "size", NULL
3852 };
3853
3854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3856 if (SWIG_arg_fail(1)) SWIG_fail;
3857 {
3858 arg2 = &temp2;
3859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3860 }
3861 {
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 (arg1)->SetDefaults((wxSize const &)*arg2);
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 Py_INCREF(Py_None); resultobj = Py_None;
3869 return resultobj;
3870 fail:
3871 return NULL;
3872 }
3873
3874
3875 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3876 PyObject *resultobj;
3877 wxSize *arg1 = (wxSize *) 0 ;
3878 PyObject *result;
3879 PyObject * obj0 = 0 ;
3880 char *kwnames[] = {
3881 (char *) "self", NULL
3882 };
3883
3884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3886 if (SWIG_arg_fail(1)) SWIG_fail;
3887 {
3888 PyThreadState* __tstate = wxPyBeginAllowThreads();
3889 result = (PyObject *)wxSize_Get(arg1);
3890
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 resultobj = result;
3895 return resultobj;
3896 fail:
3897 return NULL;
3898 }
3899
3900
3901 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3902 PyObject *obj;
3903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3904 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3905 Py_INCREF(obj);
3906 return Py_BuildValue((char *)"");
3907 }
3908 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3909 PyObject *resultobj;
3910 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3911 double arg2 ;
3912 PyObject * obj0 = 0 ;
3913 PyObject * obj1 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self",(char *) "x", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 arg2 = (double)(SWIG_As_double(obj1));
3923 if (SWIG_arg_fail(2)) SWIG_fail;
3924 }
3925 if (arg1) (arg1)->x = arg2;
3926
3927 Py_INCREF(Py_None); resultobj = Py_None;
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3935 PyObject *resultobj;
3936 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3937 double result;
3938 PyObject * obj0 = 0 ;
3939 char *kwnames[] = {
3940 (char *) "self", NULL
3941 };
3942
3943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3945 if (SWIG_arg_fail(1)) SWIG_fail;
3946 result = (double) ((arg1)->x);
3947
3948 {
3949 resultobj = SWIG_From_double((double)(result));
3950 }
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj;
3959 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3960 double arg2 ;
3961 PyObject * obj0 = 0 ;
3962 PyObject * obj1 = 0 ;
3963 char *kwnames[] = {
3964 (char *) "self",(char *) "y", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3969 if (SWIG_arg_fail(1)) SWIG_fail;
3970 {
3971 arg2 = (double)(SWIG_As_double(obj1));
3972 if (SWIG_arg_fail(2)) SWIG_fail;
3973 }
3974 if (arg1) (arg1)->y = arg2;
3975
3976 Py_INCREF(Py_None); resultobj = Py_None;
3977 return resultobj;
3978 fail:
3979 return NULL;
3980 }
3981
3982
3983 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3984 PyObject *resultobj;
3985 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3986 double result;
3987 PyObject * obj0 = 0 ;
3988 char *kwnames[] = {
3989 (char *) "self", NULL
3990 };
3991
3992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3994 if (SWIG_arg_fail(1)) SWIG_fail;
3995 result = (double) ((arg1)->y);
3996
3997 {
3998 resultobj = SWIG_From_double((double)(result));
3999 }
4000 return resultobj;
4001 fail:
4002 return NULL;
4003 }
4004
4005
4006 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4007 PyObject *resultobj;
4008 double arg1 = (double) 0.0 ;
4009 double arg2 = (double) 0.0 ;
4010 wxRealPoint *result;
4011 PyObject * obj0 = 0 ;
4012 PyObject * obj1 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "x",(char *) "y", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4018 if (obj0) {
4019 {
4020 arg1 = (double)(SWIG_As_double(obj0));
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 }
4023 }
4024 if (obj1) {
4025 {
4026 arg2 = (double)(SWIG_As_double(obj1));
4027 if (SWIG_arg_fail(2)) SWIG_fail;
4028 }
4029 }
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4038 return resultobj;
4039 fail:
4040 return NULL;
4041 }
4042
4043
4044 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4045 PyObject *resultobj;
4046 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4047 PyObject * obj0 = 0 ;
4048 char *kwnames[] = {
4049 (char *) "self", NULL
4050 };
4051
4052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4054 if (SWIG_arg_fail(1)) SWIG_fail;
4055 {
4056 PyThreadState* __tstate = wxPyBeginAllowThreads();
4057 delete arg1;
4058
4059 wxPyEndAllowThreads(__tstate);
4060 if (PyErr_Occurred()) SWIG_fail;
4061 }
4062 Py_INCREF(Py_None); resultobj = Py_None;
4063 return resultobj;
4064 fail:
4065 return NULL;
4066 }
4067
4068
4069 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj;
4071 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4072 wxRealPoint *arg2 = 0 ;
4073 bool result;
4074 wxRealPoint temp2 ;
4075 PyObject * obj0 = 0 ;
4076 PyObject * obj1 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "self",(char *) "pt", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4083 if (SWIG_arg_fail(1)) SWIG_fail;
4084 {
4085 arg2 = &temp2;
4086 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4087 }
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 {
4096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4097 }
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4107 wxRealPoint *arg2 = 0 ;
4108 bool result;
4109 wxRealPoint temp2 ;
4110 PyObject * obj0 = 0 ;
4111 PyObject * obj1 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "self",(char *) "pt", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 {
4120 arg2 = &temp2;
4121 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4122 }
4123 {
4124 PyThreadState* __tstate = wxPyBeginAllowThreads();
4125 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4126
4127 wxPyEndAllowThreads(__tstate);
4128 if (PyErr_Occurred()) SWIG_fail;
4129 }
4130 {
4131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4132 }
4133 return resultobj;
4134 fail:
4135 return NULL;
4136 }
4137
4138
4139 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4140 PyObject *resultobj;
4141 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4142 wxRealPoint *arg2 = 0 ;
4143 wxRealPoint result;
4144 wxRealPoint temp2 ;
4145 PyObject * obj0 = 0 ;
4146 PyObject * obj1 = 0 ;
4147 char *kwnames[] = {
4148 (char *) "self",(char *) "pt", NULL
4149 };
4150
4151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4153 if (SWIG_arg_fail(1)) SWIG_fail;
4154 {
4155 arg2 = &temp2;
4156 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4157 }
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 wxRealPoint * resultptr;
4167 resultptr = new wxRealPoint((wxRealPoint &)(result));
4168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4169 }
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4179 wxRealPoint *arg2 = 0 ;
4180 wxRealPoint result;
4181 wxRealPoint temp2 ;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "self",(char *) "pt", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4190 if (SWIG_arg_fail(1)) SWIG_fail;
4191 {
4192 arg2 = &temp2;
4193 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4194 }
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 {
4203 wxRealPoint * resultptr;
4204 resultptr = new wxRealPoint((wxRealPoint &)(result));
4205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4216 double arg2 ;
4217 double arg3 ;
4218 PyObject * obj0 = 0 ;
4219 PyObject * obj1 = 0 ;
4220 PyObject * obj2 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "self",(char *) "x",(char *) "y", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4227 if (SWIG_arg_fail(1)) SWIG_fail;
4228 {
4229 arg2 = (double)(SWIG_As_double(obj1));
4230 if (SWIG_arg_fail(2)) SWIG_fail;
4231 }
4232 {
4233 arg3 = (double)(SWIG_As_double(obj2));
4234 if (SWIG_arg_fail(3)) SWIG_fail;
4235 }
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 wxRealPoint_Set(arg1,arg2,arg3);
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 Py_INCREF(Py_None); resultobj = Py_None;
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj;
4252 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4253 PyObject *result;
4254 PyObject * obj0 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "self", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4261 if (SWIG_arg_fail(1)) SWIG_fail;
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = (PyObject *)wxRealPoint_Get(arg1);
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 resultobj = result;
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4277 PyObject *obj;
4278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4279 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4280 Py_INCREF(obj);
4281 return Py_BuildValue((char *)"");
4282 }
4283 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4284 PyObject *resultobj;
4285 wxPoint *arg1 = (wxPoint *) 0 ;
4286 int arg2 ;
4287 PyObject * obj0 = 0 ;
4288 PyObject * obj1 = 0 ;
4289 char *kwnames[] = {
4290 (char *) "self",(char *) "x", NULL
4291 };
4292
4293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4295 if (SWIG_arg_fail(1)) SWIG_fail;
4296 {
4297 arg2 = (int)(SWIG_As_int(obj1));
4298 if (SWIG_arg_fail(2)) SWIG_fail;
4299 }
4300 if (arg1) (arg1)->x = arg2;
4301
4302 Py_INCREF(Py_None); resultobj = Py_None;
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxPoint *arg1 = (wxPoint *) 0 ;
4312 int result;
4313 PyObject * obj0 = 0 ;
4314 char *kwnames[] = {
4315 (char *) "self", NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4320 if (SWIG_arg_fail(1)) SWIG_fail;
4321 result = (int) ((arg1)->x);
4322
4323 {
4324 resultobj = SWIG_From_int((int)(result));
4325 }
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj;
4334 wxPoint *arg1 = (wxPoint *) 0 ;
4335 int arg2 ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char *kwnames[] = {
4339 (char *) "self",(char *) "y", NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4344 if (SWIG_arg_fail(1)) SWIG_fail;
4345 {
4346 arg2 = (int)(SWIG_As_int(obj1));
4347 if (SWIG_arg_fail(2)) SWIG_fail;
4348 }
4349 if (arg1) (arg1)->y = arg2;
4350
4351 Py_INCREF(Py_None); resultobj = Py_None;
4352 return resultobj;
4353 fail:
4354 return NULL;
4355 }
4356
4357
4358 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4359 PyObject *resultobj;
4360 wxPoint *arg1 = (wxPoint *) 0 ;
4361 int result;
4362 PyObject * obj0 = 0 ;
4363 char *kwnames[] = {
4364 (char *) "self", NULL
4365 };
4366
4367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4369 if (SWIG_arg_fail(1)) SWIG_fail;
4370 result = (int) ((arg1)->y);
4371
4372 {
4373 resultobj = SWIG_From_int((int)(result));
4374 }
4375 return resultobj;
4376 fail:
4377 return NULL;
4378 }
4379
4380
4381 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4382 PyObject *resultobj;
4383 int arg1 = (int) 0 ;
4384 int arg2 = (int) 0 ;
4385 wxPoint *result;
4386 PyObject * obj0 = 0 ;
4387 PyObject * obj1 = 0 ;
4388 char *kwnames[] = {
4389 (char *) "x",(char *) "y", NULL
4390 };
4391
4392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4393 if (obj0) {
4394 {
4395 arg1 = (int)(SWIG_As_int(obj0));
4396 if (SWIG_arg_fail(1)) SWIG_fail;
4397 }
4398 }
4399 if (obj1) {
4400 {
4401 arg2 = (int)(SWIG_As_int(obj1));
4402 if (SWIG_arg_fail(2)) SWIG_fail;
4403 }
4404 }
4405 {
4406 PyThreadState* __tstate = wxPyBeginAllowThreads();
4407 result = (wxPoint *)new wxPoint(arg1,arg2);
4408
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4413 return resultobj;
4414 fail:
4415 return NULL;
4416 }
4417
4418
4419 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj;
4421 wxPoint *arg1 = (wxPoint *) 0 ;
4422 PyObject * obj0 = 0 ;
4423 char *kwnames[] = {
4424 (char *) "self", NULL
4425 };
4426
4427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4429 if (SWIG_arg_fail(1)) SWIG_fail;
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 delete arg1;
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 Py_INCREF(Py_None); resultobj = Py_None;
4438 return resultobj;
4439 fail:
4440 return NULL;
4441 }
4442
4443
4444 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4445 PyObject *resultobj;
4446 wxPoint *arg1 = (wxPoint *) 0 ;
4447 wxPoint *arg2 = 0 ;
4448 bool result;
4449 wxPoint temp2 ;
4450 PyObject * obj0 = 0 ;
4451 PyObject * obj1 = 0 ;
4452 char *kwnames[] = {
4453 (char *) "self",(char *) "pt", NULL
4454 };
4455
4456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4458 if (SWIG_arg_fail(1)) SWIG_fail;
4459 {
4460 arg2 = &temp2;
4461 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4462 }
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4466
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 {
4471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4472 }
4473 return resultobj;
4474 fail:
4475 return NULL;
4476 }
4477
4478
4479 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4480 PyObject *resultobj;
4481 wxPoint *arg1 = (wxPoint *) 0 ;
4482 wxPoint *arg2 = 0 ;
4483 bool result;
4484 wxPoint temp2 ;
4485 PyObject * obj0 = 0 ;
4486 PyObject * obj1 = 0 ;
4487 char *kwnames[] = {
4488 (char *) "self",(char *) "pt", NULL
4489 };
4490
4491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4493 if (SWIG_arg_fail(1)) SWIG_fail;
4494 {
4495 arg2 = &temp2;
4496 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4497 }
4498 {
4499 PyThreadState* __tstate = wxPyBeginAllowThreads();
4500 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4501
4502 wxPyEndAllowThreads(__tstate);
4503 if (PyErr_Occurred()) SWIG_fail;
4504 }
4505 {
4506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4507 }
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4515 PyObject *resultobj;
4516 wxPoint *arg1 = (wxPoint *) 0 ;
4517 wxPoint *arg2 = 0 ;
4518 wxPoint result;
4519 wxPoint temp2 ;
4520 PyObject * obj0 = 0 ;
4521 PyObject * obj1 = 0 ;
4522 char *kwnames[] = {
4523 (char *) "self",(char *) "pt", NULL
4524 };
4525
4526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4528 if (SWIG_arg_fail(1)) SWIG_fail;
4529 {
4530 arg2 = &temp2;
4531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4532 }
4533 {
4534 PyThreadState* __tstate = wxPyBeginAllowThreads();
4535 result = (arg1)->operator +((wxPoint const &)*arg2);
4536
4537 wxPyEndAllowThreads(__tstate);
4538 if (PyErr_Occurred()) SWIG_fail;
4539 }
4540 {
4541 wxPoint * resultptr;
4542 resultptr = new wxPoint((wxPoint &)(result));
4543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj;
4553 wxPoint *arg1 = (wxPoint *) 0 ;
4554 wxPoint *arg2 = 0 ;
4555 wxPoint result;
4556 wxPoint temp2 ;
4557 PyObject * obj0 = 0 ;
4558 PyObject * obj1 = 0 ;
4559 char *kwnames[] = {
4560 (char *) "self",(char *) "pt", NULL
4561 };
4562
4563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4565 if (SWIG_arg_fail(1)) SWIG_fail;
4566 {
4567 arg2 = &temp2;
4568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (arg1)->operator -((wxPoint const &)*arg2);
4573
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 wxPoint * resultptr;
4579 resultptr = new wxPoint((wxPoint &)(result));
4580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj;
4590 wxPoint *arg1 = (wxPoint *) 0 ;
4591 wxPoint *arg2 = 0 ;
4592 wxPoint *result;
4593 wxPoint temp2 ;
4594 PyObject * obj0 = 0 ;
4595 PyObject * obj1 = 0 ;
4596 char *kwnames[] = {
4597 (char *) "self",(char *) "pt", NULL
4598 };
4599
4600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4602 if (SWIG_arg_fail(1)) SWIG_fail;
4603 {
4604 arg2 = &temp2;
4605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4606 }
4607 {
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 {
4610 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4611 result = (wxPoint *) &_result_ref;
4612 }
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj;
4626 wxPoint *arg1 = (wxPoint *) 0 ;
4627 wxPoint *arg2 = 0 ;
4628 wxPoint *result;
4629 wxPoint temp2 ;
4630 PyObject * obj0 = 0 ;
4631 PyObject * obj1 = 0 ;
4632 char *kwnames[] = {
4633 (char *) "self",(char *) "pt", NULL
4634 };
4635
4636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4638 if (SWIG_arg_fail(1)) SWIG_fail;
4639 {
4640 arg2 = &temp2;
4641 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4642 }
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 {
4646 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4647 result = (wxPoint *) &_result_ref;
4648 }
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj;
4662 wxPoint *arg1 = (wxPoint *) 0 ;
4663 long arg2 ;
4664 long arg3 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 PyObject * obj2 = 0 ;
4668 char *kwnames[] = {
4669 (char *) "self",(char *) "x",(char *) "y", NULL
4670 };
4671
4672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4674 if (SWIG_arg_fail(1)) SWIG_fail;
4675 {
4676 arg2 = (long)(SWIG_As_long(obj1));
4677 if (SWIG_arg_fail(2)) SWIG_fail;
4678 }
4679 {
4680 arg3 = (long)(SWIG_As_long(obj2));
4681 if (SWIG_arg_fail(3)) SWIG_fail;
4682 }
4683 {
4684 PyThreadState* __tstate = wxPyBeginAllowThreads();
4685 wxPoint_Set(arg1,arg2,arg3);
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 Py_INCREF(Py_None); resultobj = Py_None;
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxPoint *arg1 = (wxPoint *) 0 ;
4700 PyObject *result;
4701 PyObject * obj0 = 0 ;
4702 char *kwnames[] = {
4703 (char *) "self", NULL
4704 };
4705
4706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4708 if (SWIG_arg_fail(1)) SWIG_fail;
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (PyObject *)wxPoint_Get(arg1);
4712
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 resultobj = result;
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4724 PyObject *obj;
4725 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4726 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4727 Py_INCREF(obj);
4728 return Py_BuildValue((char *)"");
4729 }
4730 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj;
4732 int arg1 = (int) 0 ;
4733 int arg2 = (int) 0 ;
4734 int arg3 = (int) 0 ;
4735 int arg4 = (int) 0 ;
4736 wxRect *result;
4737 PyObject * obj0 = 0 ;
4738 PyObject * obj1 = 0 ;
4739 PyObject * obj2 = 0 ;
4740 PyObject * obj3 = 0 ;
4741 char *kwnames[] = {
4742 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4743 };
4744
4745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4746 if (obj0) {
4747 {
4748 arg1 = (int)(SWIG_As_int(obj0));
4749 if (SWIG_arg_fail(1)) SWIG_fail;
4750 }
4751 }
4752 if (obj1) {
4753 {
4754 arg2 = (int)(SWIG_As_int(obj1));
4755 if (SWIG_arg_fail(2)) SWIG_fail;
4756 }
4757 }
4758 if (obj2) {
4759 {
4760 arg3 = (int)(SWIG_As_int(obj2));
4761 if (SWIG_arg_fail(3)) SWIG_fail;
4762 }
4763 }
4764 if (obj3) {
4765 {
4766 arg4 = (int)(SWIG_As_int(obj3));
4767 if (SWIG_arg_fail(4)) SWIG_fail;
4768 }
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4773
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 wxPoint *arg1 = 0 ;
4787 wxPoint *arg2 = 0 ;
4788 wxRect *result;
4789 wxPoint temp1 ;
4790 wxPoint temp2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char *kwnames[] = {
4794 (char *) "topLeft",(char *) "bottomRight", NULL
4795 };
4796
4797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4798 {
4799 arg1 = &temp1;
4800 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4801 }
4802 {
4803 arg2 = &temp2;
4804 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4805 }
4806 {
4807 PyThreadState* __tstate = wxPyBeginAllowThreads();
4808 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4809
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj;
4822 wxPoint *arg1 = 0 ;
4823 wxSize *arg2 = 0 ;
4824 wxRect *result;
4825 wxPoint temp1 ;
4826 wxSize temp2 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4829 char *kwnames[] = {
4830 (char *) "pos",(char *) "size", NULL
4831 };
4832
4833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4834 {
4835 arg1 = &temp1;
4836 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4837 }
4838 {
4839 arg2 = &temp2;
4840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4841 }
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4845
4846 wxPyEndAllowThreads(__tstate);
4847 if (PyErr_Occurred()) SWIG_fail;
4848 }
4849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj;
4858 wxSize *arg1 = 0 ;
4859 wxRect *result;
4860 wxSize temp1 ;
4861 PyObject * obj0 = 0 ;
4862 char *kwnames[] = {
4863 (char *) "size", NULL
4864 };
4865
4866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4867 {
4868 arg1 = &temp1;
4869 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4870 }
4871 {
4872 PyThreadState* __tstate = wxPyBeginAllowThreads();
4873 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4874
4875 wxPyEndAllowThreads(__tstate);
4876 if (PyErr_Occurred()) SWIG_fail;
4877 }
4878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4879 return resultobj;
4880 fail:
4881 return NULL;
4882 }
4883
4884
4885 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4886 PyObject *resultobj;
4887 wxRect *arg1 = (wxRect *) 0 ;
4888 PyObject * obj0 = 0 ;
4889 char *kwnames[] = {
4890 (char *) "self", NULL
4891 };
4892
4893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(1)) SWIG_fail;
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 delete arg1;
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 Py_INCREF(Py_None); resultobj = Py_None;
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxRect *arg1 = (wxRect *) 0 ;
4913 int result;
4914 PyObject * obj0 = 0 ;
4915 char *kwnames[] = {
4916 (char *) "self", NULL
4917 };
4918
4919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4921 if (SWIG_arg_fail(1)) SWIG_fail;
4922 {
4923 PyThreadState* __tstate = wxPyBeginAllowThreads();
4924 result = (int)((wxRect const *)arg1)->GetX();
4925
4926 wxPyEndAllowThreads(__tstate);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 {
4930 resultobj = SWIG_From_int((int)(result));
4931 }
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxRect *arg1 = (wxRect *) 0 ;
4941 int arg2 ;
4942 PyObject * obj0 = 0 ;
4943 PyObject * obj1 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "self",(char *) "x", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4950 if (SWIG_arg_fail(1)) SWIG_fail;
4951 {
4952 arg2 = (int)(SWIG_As_int(obj1));
4953 if (SWIG_arg_fail(2)) SWIG_fail;
4954 }
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 (arg1)->SetX(arg2);
4958
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 Py_INCREF(Py_None); resultobj = Py_None;
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj;
4971 wxRect *arg1 = (wxRect *) 0 ;
4972 int result;
4973 PyObject * obj0 = 0 ;
4974 char *kwnames[] = {
4975 (char *) "self", NULL
4976 };
4977
4978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4980 if (SWIG_arg_fail(1)) SWIG_fail;
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (int)(arg1)->GetY();
4984
4985 wxPyEndAllowThreads(__tstate);
4986 if (PyErr_Occurred()) SWIG_fail;
4987 }
4988 {
4989 resultobj = SWIG_From_int((int)(result));
4990 }
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj;
4999 wxRect *arg1 = (wxRect *) 0 ;
5000 int arg2 ;
5001 PyObject * obj0 = 0 ;
5002 PyObject * obj1 = 0 ;
5003 char *kwnames[] = {
5004 (char *) "self",(char *) "y", NULL
5005 };
5006
5007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5009 if (SWIG_arg_fail(1)) SWIG_fail;
5010 {
5011 arg2 = (int)(SWIG_As_int(obj1));
5012 if (SWIG_arg_fail(2)) SWIG_fail;
5013 }
5014 {
5015 PyThreadState* __tstate = wxPyBeginAllowThreads();
5016 (arg1)->SetY(arg2);
5017
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 Py_INCREF(Py_None); resultobj = Py_None;
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5029 PyObject *resultobj;
5030 wxRect *arg1 = (wxRect *) 0 ;
5031 int result;
5032 PyObject * obj0 = 0 ;
5033 char *kwnames[] = {
5034 (char *) "self", NULL
5035 };
5036
5037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5039 if (SWIG_arg_fail(1)) SWIG_fail;
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (int)((wxRect const *)arg1)->GetWidth();
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 {
5048 resultobj = SWIG_From_int((int)(result));
5049 }
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj;
5058 wxRect *arg1 = (wxRect *) 0 ;
5059 int arg2 ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062 char *kwnames[] = {
5063 (char *) "self",(char *) "w", NULL
5064 };
5065
5066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5068 if (SWIG_arg_fail(1)) SWIG_fail;
5069 {
5070 arg2 = (int)(SWIG_As_int(obj1));
5071 if (SWIG_arg_fail(2)) SWIG_fail;
5072 }
5073 {
5074 PyThreadState* __tstate = wxPyBeginAllowThreads();
5075 (arg1)->SetWidth(arg2);
5076
5077 wxPyEndAllowThreads(__tstate);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 Py_INCREF(Py_None); resultobj = Py_None;
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5088 PyObject *resultobj;
5089 wxRect *arg1 = (wxRect *) 0 ;
5090 int result;
5091 PyObject * obj0 = 0 ;
5092 char *kwnames[] = {
5093 (char *) "self", NULL
5094 };
5095
5096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5098 if (SWIG_arg_fail(1)) SWIG_fail;
5099 {
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (int)((wxRect const *)arg1)->GetHeight();
5102
5103 wxPyEndAllowThreads(__tstate);
5104 if (PyErr_Occurred()) SWIG_fail;
5105 }
5106 {
5107 resultobj = SWIG_From_int((int)(result));
5108 }
5109 return resultobj;
5110 fail:
5111 return NULL;
5112 }
5113
5114
5115 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5116 PyObject *resultobj;
5117 wxRect *arg1 = (wxRect *) 0 ;
5118 int arg2 ;
5119 PyObject * obj0 = 0 ;
5120 PyObject * obj1 = 0 ;
5121 char *kwnames[] = {
5122 (char *) "self",(char *) "h", NULL
5123 };
5124
5125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5127 if (SWIG_arg_fail(1)) SWIG_fail;
5128 {
5129 arg2 = (int)(SWIG_As_int(obj1));
5130 if (SWIG_arg_fail(2)) SWIG_fail;
5131 }
5132 {
5133 PyThreadState* __tstate = wxPyBeginAllowThreads();
5134 (arg1)->SetHeight(arg2);
5135
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 Py_INCREF(Py_None); resultobj = Py_None;
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj;
5148 wxRect *arg1 = (wxRect *) 0 ;
5149 wxPoint result;
5150 PyObject * obj0 = 0 ;
5151 char *kwnames[] = {
5152 (char *) "self", NULL
5153 };
5154
5155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5157 if (SWIG_arg_fail(1)) SWIG_fail;
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = ((wxRect const *)arg1)->GetPosition();
5161
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 {
5166 wxPoint * resultptr;
5167 resultptr = new wxPoint((wxPoint &)(result));
5168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5177 PyObject *resultobj;
5178 wxRect *arg1 = (wxRect *) 0 ;
5179 wxPoint *arg2 = 0 ;
5180 wxPoint temp2 ;
5181 PyObject * obj0 = 0 ;
5182 PyObject * obj1 = 0 ;
5183 char *kwnames[] = {
5184 (char *) "self",(char *) "p", NULL
5185 };
5186
5187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5189 if (SWIG_arg_fail(1)) SWIG_fail;
5190 {
5191 arg2 = &temp2;
5192 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5193 }
5194 {
5195 PyThreadState* __tstate = wxPyBeginAllowThreads();
5196 (arg1)->SetPosition((wxPoint const &)*arg2);
5197
5198 wxPyEndAllowThreads(__tstate);
5199 if (PyErr_Occurred()) SWIG_fail;
5200 }
5201 Py_INCREF(Py_None); resultobj = Py_None;
5202 return resultobj;
5203 fail:
5204 return NULL;
5205 }
5206
5207
5208 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5209 PyObject *resultobj;
5210 wxRect *arg1 = (wxRect *) 0 ;
5211 wxSize result;
5212 PyObject * obj0 = 0 ;
5213 char *kwnames[] = {
5214 (char *) "self", NULL
5215 };
5216
5217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5219 if (SWIG_arg_fail(1)) SWIG_fail;
5220 {
5221 PyThreadState* __tstate = wxPyBeginAllowThreads();
5222 result = ((wxRect const *)arg1)->GetSize();
5223
5224 wxPyEndAllowThreads(__tstate);
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 {
5228 wxSize * resultptr;
5229 resultptr = new wxSize((wxSize &)(result));
5230 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5231 }
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5239 PyObject *resultobj;
5240 wxRect *arg1 = (wxRect *) 0 ;
5241 wxSize *arg2 = 0 ;
5242 wxSize temp2 ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char *kwnames[] = {
5246 (char *) "self",(char *) "s", NULL
5247 };
5248
5249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5251 if (SWIG_arg_fail(1)) SWIG_fail;
5252 {
5253 arg2 = &temp2;
5254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5255 }
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 (arg1)->SetSize((wxSize const &)*arg2);
5259
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 Py_INCREF(Py_None); resultobj = Py_None;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5271 PyObject *resultobj;
5272 wxRect *arg1 = (wxRect *) 0 ;
5273 wxPoint result;
5274 PyObject * obj0 = 0 ;
5275 char *kwnames[] = {
5276 (char *) "self", NULL
5277 };
5278
5279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5281 if (SWIG_arg_fail(1)) SWIG_fail;
5282 {
5283 PyThreadState* __tstate = wxPyBeginAllowThreads();
5284 result = ((wxRect const *)arg1)->GetTopLeft();
5285
5286 wxPyEndAllowThreads(__tstate);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 {
5290 wxPoint * resultptr;
5291 resultptr = new wxPoint((wxPoint &)(result));
5292 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5293 }
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj;
5302 wxRect *arg1 = (wxRect *) 0 ;
5303 wxPoint *arg2 = 0 ;
5304 wxPoint temp2 ;
5305 PyObject * obj0 = 0 ;
5306 PyObject * obj1 = 0 ;
5307 char *kwnames[] = {
5308 (char *) "self",(char *) "p", NULL
5309 };
5310
5311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5313 if (SWIG_arg_fail(1)) SWIG_fail;
5314 {
5315 arg2 = &temp2;
5316 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5317 }
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5321
5322 wxPyEndAllowThreads(__tstate);
5323 if (PyErr_Occurred()) SWIG_fail;
5324 }
5325 Py_INCREF(Py_None); resultobj = Py_None;
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj;
5334 wxRect *arg1 = (wxRect *) 0 ;
5335 wxPoint result;
5336 PyObject * obj0 = 0 ;
5337 char *kwnames[] = {
5338 (char *) "self", NULL
5339 };
5340
5341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5343 if (SWIG_arg_fail(1)) SWIG_fail;
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 result = ((wxRect const *)arg1)->GetBottomRight();
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 {
5352 wxPoint * resultptr;
5353 resultptr = new wxPoint((wxPoint &)(result));
5354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5355 }
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj;
5364 wxRect *arg1 = (wxRect *) 0 ;
5365 wxPoint *arg2 = 0 ;
5366 wxPoint temp2 ;
5367 PyObject * obj0 = 0 ;
5368 PyObject * obj1 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self",(char *) "p", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 {
5377 arg2 = &temp2;
5378 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5379 }
5380 {
5381 PyThreadState* __tstate = wxPyBeginAllowThreads();
5382 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5383
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 Py_INCREF(Py_None); resultobj = Py_None;
5388 return resultobj;
5389 fail:
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxRect *arg1 = (wxRect *) 0 ;
5397 int result;
5398 PyObject * obj0 = 0 ;
5399 char *kwnames[] = {
5400 (char *) "self", NULL
5401 };
5402
5403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5405 if (SWIG_arg_fail(1)) SWIG_fail;
5406 {
5407 PyThreadState* __tstate = wxPyBeginAllowThreads();
5408 result = (int)((wxRect const *)arg1)->GetLeft();
5409
5410 wxPyEndAllowThreads(__tstate);
5411 if (PyErr_Occurred()) SWIG_fail;
5412 }
5413 {
5414 resultobj = SWIG_From_int((int)(result));
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 wxRect *arg1 = (wxRect *) 0 ;
5425 int result;
5426 PyObject * obj0 = 0 ;
5427 char *kwnames[] = {
5428 (char *) "self", NULL
5429 };
5430
5431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5433 if (SWIG_arg_fail(1)) SWIG_fail;
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = (int)((wxRect const *)arg1)->GetTop();
5437
5438 wxPyEndAllowThreads(__tstate);
5439 if (PyErr_Occurred()) SWIG_fail;
5440 }
5441 {
5442 resultobj = SWIG_From_int((int)(result));
5443 }
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj;
5452 wxRect *arg1 = (wxRect *) 0 ;
5453 int result;
5454 PyObject * obj0 = 0 ;
5455 char *kwnames[] = {
5456 (char *) "self", NULL
5457 };
5458
5459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5461 if (SWIG_arg_fail(1)) SWIG_fail;
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 result = (int)((wxRect const *)arg1)->GetBottom();
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 resultobj = SWIG_From_int((int)(result));
5471 }
5472 return resultobj;
5473 fail:
5474 return NULL;
5475 }
5476
5477
5478 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5479 PyObject *resultobj;
5480 wxRect *arg1 = (wxRect *) 0 ;
5481 int result;
5482 PyObject * obj0 = 0 ;
5483 char *kwnames[] = {
5484 (char *) "self", NULL
5485 };
5486
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5489 if (SWIG_arg_fail(1)) SWIG_fail;
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (int)((wxRect const *)arg1)->GetRight();
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = SWIG_From_int((int)(result));
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj;
5508 wxRect *arg1 = (wxRect *) 0 ;
5509 int arg2 ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 char *kwnames[] = {
5513 (char *) "self",(char *) "left", NULL
5514 };
5515
5516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5518 if (SWIG_arg_fail(1)) SWIG_fail;
5519 {
5520 arg2 = (int)(SWIG_As_int(obj1));
5521 if (SWIG_arg_fail(2)) SWIG_fail;
5522 }
5523 {
5524 PyThreadState* __tstate = wxPyBeginAllowThreads();
5525 (arg1)->SetLeft(arg2);
5526
5527 wxPyEndAllowThreads(__tstate);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 Py_INCREF(Py_None); resultobj = Py_None;
5531 return resultobj;
5532 fail:
5533 return NULL;
5534 }
5535
5536
5537 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5538 PyObject *resultobj;
5539 wxRect *arg1 = (wxRect *) 0 ;
5540 int arg2 ;
5541 PyObject * obj0 = 0 ;
5542 PyObject * obj1 = 0 ;
5543 char *kwnames[] = {
5544 (char *) "self",(char *) "right", NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5549 if (SWIG_arg_fail(1)) SWIG_fail;
5550 {
5551 arg2 = (int)(SWIG_As_int(obj1));
5552 if (SWIG_arg_fail(2)) SWIG_fail;
5553 }
5554 {
5555 PyThreadState* __tstate = wxPyBeginAllowThreads();
5556 (arg1)->SetRight(arg2);
5557
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 Py_INCREF(Py_None); resultobj = Py_None;
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj;
5570 wxRect *arg1 = (wxRect *) 0 ;
5571 int arg2 ;
5572 PyObject * obj0 = 0 ;
5573 PyObject * obj1 = 0 ;
5574 char *kwnames[] = {
5575 (char *) "self",(char *) "top", NULL
5576 };
5577
5578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5580 if (SWIG_arg_fail(1)) SWIG_fail;
5581 {
5582 arg2 = (int)(SWIG_As_int(obj1));
5583 if (SWIG_arg_fail(2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 (arg1)->SetTop(arg2);
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 Py_INCREF(Py_None); resultobj = Py_None;
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 wxRect *arg1 = (wxRect *) 0 ;
5602 int arg2 ;
5603 PyObject * obj0 = 0 ;
5604 PyObject * obj1 = 0 ;
5605 char *kwnames[] = {
5606 (char *) "self",(char *) "bottom", NULL
5607 };
5608
5609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5611 if (SWIG_arg_fail(1)) SWIG_fail;
5612 {
5613 arg2 = (int)(SWIG_As_int(obj1));
5614 if (SWIG_arg_fail(2)) SWIG_fail;
5615 }
5616 {
5617 PyThreadState* __tstate = wxPyBeginAllowThreads();
5618 (arg1)->SetBottom(arg2);
5619
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 Py_INCREF(Py_None); resultobj = Py_None;
5624 return resultobj;
5625 fail:
5626 return NULL;
5627 }
5628
5629
5630 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5631 PyObject *resultobj;
5632 wxRect *arg1 = (wxRect *) 0 ;
5633 int arg2 ;
5634 int arg3 ;
5635 wxRect *result;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 PyObject * obj2 = 0 ;
5639 char *kwnames[] = {
5640 (char *) "self",(char *) "dx",(char *) "dy", NULL
5641 };
5642
5643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5645 if (SWIG_arg_fail(1)) SWIG_fail;
5646 {
5647 arg2 = (int)(SWIG_As_int(obj1));
5648 if (SWIG_arg_fail(2)) SWIG_fail;
5649 }
5650 {
5651 arg3 = (int)(SWIG_As_int(obj2));
5652 if (SWIG_arg_fail(3)) SWIG_fail;
5653 }
5654 {
5655 PyThreadState* __tstate = wxPyBeginAllowThreads();
5656 {
5657 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5658 result = (wxRect *) &_result_ref;
5659 }
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 int arg3 ;
5676 wxRect *result;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 PyObject * obj2 = 0 ;
5680 char *kwnames[] = {
5681 (char *) "self",(char *) "dx",(char *) "dy", NULL
5682 };
5683
5684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5686 if (SWIG_arg_fail(1)) SWIG_fail;
5687 {
5688 arg2 = (int)(SWIG_As_int(obj1));
5689 if (SWIG_arg_fail(2)) SWIG_fail;
5690 }
5691 {
5692 arg3 = (int)(SWIG_As_int(obj2));
5693 if (SWIG_arg_fail(3)) SWIG_fail;
5694 }
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 {
5698 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5699 result = (wxRect *) &_result_ref;
5700 }
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 wxRect *arg1 = (wxRect *) 0 ;
5715 int arg2 ;
5716 int arg3 ;
5717 PyObject * obj0 = 0 ;
5718 PyObject * obj1 = 0 ;
5719 PyObject * obj2 = 0 ;
5720 char *kwnames[] = {
5721 (char *) "self",(char *) "dx",(char *) "dy", NULL
5722 };
5723
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5726 if (SWIG_arg_fail(1)) SWIG_fail;
5727 {
5728 arg2 = (int)(SWIG_As_int(obj1));
5729 if (SWIG_arg_fail(2)) SWIG_fail;
5730 }
5731 {
5732 arg3 = (int)(SWIG_As_int(obj2));
5733 if (SWIG_arg_fail(3)) SWIG_fail;
5734 }
5735 {
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 (arg1)->Offset(arg2,arg3);
5738
5739 wxPyEndAllowThreads(__tstate);
5740 if (PyErr_Occurred()) SWIG_fail;
5741 }
5742 Py_INCREF(Py_None); resultobj = Py_None;
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxRect *arg1 = (wxRect *) 0 ;
5752 wxPoint *arg2 = 0 ;
5753 wxPoint temp2 ;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 char *kwnames[] = {
5757 (char *) "self",(char *) "pt", NULL
5758 };
5759
5760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5762 if (SWIG_arg_fail(1)) SWIG_fail;
5763 {
5764 arg2 = &temp2;
5765 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 (arg1)->Offset((wxPoint const &)*arg2);
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 Py_INCREF(Py_None); resultobj = Py_None;
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 wxRect *arg1 = (wxRect *) 0 ;
5784 wxRect *arg2 = 0 ;
5785 wxRect result;
5786 wxRect temp2 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "self",(char *) "rect", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5795 if (SWIG_arg_fail(1)) SWIG_fail;
5796 {
5797 arg2 = &temp2;
5798 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = (arg1)->Intersect((wxRect const &)*arg2);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 {
5808 wxRect * resultptr;
5809 resultptr = new wxRect((wxRect &)(result));
5810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5811 }
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxRect *arg1 = (wxRect *) 0 ;
5821 wxRect *arg2 = 0 ;
5822 wxRect result;
5823 wxRect temp2 ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 char *kwnames[] = {
5827 (char *) "self",(char *) "rect", NULL
5828 };
5829
5830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5832 if (SWIG_arg_fail(1)) SWIG_fail;
5833 {
5834 arg2 = &temp2;
5835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5836 }
5837 {
5838 PyThreadState* __tstate = wxPyBeginAllowThreads();
5839 result = (arg1)->Union((wxRect const &)*arg2);
5840
5841 wxPyEndAllowThreads(__tstate);
5842 if (PyErr_Occurred()) SWIG_fail;
5843 }
5844 {
5845 wxRect * resultptr;
5846 resultptr = new wxRect((wxRect &)(result));
5847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5848 }
5849 return resultobj;
5850 fail:
5851 return NULL;
5852 }
5853
5854
5855 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj;
5857 wxRect *arg1 = (wxRect *) 0 ;
5858 wxRect *arg2 = 0 ;
5859 wxRect result;
5860 wxRect temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char *kwnames[] = {
5864 (char *) "self",(char *) "rect", NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5877
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 {
5882 wxRect * resultptr;
5883 resultptr = new wxRect((wxRect &)(result));
5884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5885 }
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxRect *arg1 = (wxRect *) 0 ;
5895 wxRect *arg2 = 0 ;
5896 wxRect *result;
5897 wxRect temp2 ;
5898 PyObject * obj0 = 0 ;
5899 PyObject * obj1 = 0 ;
5900 char *kwnames[] = {
5901 (char *) "self",(char *) "rect", NULL
5902 };
5903
5904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5906 if (SWIG_arg_fail(1)) SWIG_fail;
5907 {
5908 arg2 = &temp2;
5909 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5910 }
5911 {
5912 PyThreadState* __tstate = wxPyBeginAllowThreads();
5913 {
5914 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5915 result = (wxRect *) &_result_ref;
5916 }
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxRect *arg1 = (wxRect *) 0 ;
5931 wxRect *arg2 = 0 ;
5932 bool result;
5933 wxRect temp2 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 char *kwnames[] = {
5937 (char *) "self",(char *) "rect", NULL
5938 };
5939
5940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5942 if (SWIG_arg_fail(1)) SWIG_fail;
5943 {
5944 arg2 = &temp2;
5945 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5946 }
5947 {
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj;
5965 wxRect *arg1 = (wxRect *) 0 ;
5966 wxRect *arg2 = 0 ;
5967 bool result;
5968 wxRect temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char *kwnames[] = {
5972 (char *) "self",(char *) "rect", NULL
5973 };
5974
5975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5977 if (SWIG_arg_fail(1)) SWIG_fail;
5978 {
5979 arg2 = &temp2;
5980 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5981 }
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 {
5990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5991 }
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 wxRect *arg1 = (wxRect *) 0 ;
6001 int arg2 ;
6002 int arg3 ;
6003 bool result;
6004 PyObject * obj0 = 0 ;
6005 PyObject * obj1 = 0 ;
6006 PyObject * obj2 = 0 ;
6007 char *kwnames[] = {
6008 (char *) "self",(char *) "x",(char *) "y", NULL
6009 };
6010
6011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6013 if (SWIG_arg_fail(1)) SWIG_fail;
6014 {
6015 arg2 = (int)(SWIG_As_int(obj1));
6016 if (SWIG_arg_fail(2)) SWIG_fail;
6017 }
6018 {
6019 arg3 = (int)(SWIG_As_int(obj2));
6020 if (SWIG_arg_fail(3)) SWIG_fail;
6021 }
6022 {
6023 PyThreadState* __tstate = wxPyBeginAllowThreads();
6024 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6025
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 {
6030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6031 }
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 wxPoint *arg2 = 0 ;
6042 bool result;
6043 wxPoint temp2 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 char *kwnames[] = {
6047 (char *) "self",(char *) "pt", NULL
6048 };
6049
6050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6052 if (SWIG_arg_fail(1)) SWIG_fail;
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 PyThreadState* __tstate = wxPyBeginAllowThreads();
6059 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6060
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 {
6065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6066 }
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj;
6075 wxRect *arg1 = (wxRect *) 0 ;
6076 wxRect *arg2 = 0 ;
6077 bool result;
6078 wxRect temp2 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 char *kwnames[] = {
6082 (char *) "self",(char *) "rect", NULL
6083 };
6084
6085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6087 if (SWIG_arg_fail(1)) SWIG_fail;
6088 {
6089 arg2 = &temp2;
6090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6091 }
6092 {
6093 PyThreadState* __tstate = wxPyBeginAllowThreads();
6094 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6095
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 {
6100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6101 }
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj;
6110 wxRect *arg1 = (wxRect *) 0 ;
6111 int arg2 ;
6112 PyObject * obj0 = 0 ;
6113 PyObject * obj1 = 0 ;
6114 char *kwnames[] = {
6115 (char *) "self",(char *) "x", NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6120 if (SWIG_arg_fail(1)) SWIG_fail;
6121 {
6122 arg2 = (int)(SWIG_As_int(obj1));
6123 if (SWIG_arg_fail(2)) SWIG_fail;
6124 }
6125 if (arg1) (arg1)->x = arg2;
6126
6127 Py_INCREF(Py_None); resultobj = Py_None;
6128 return resultobj;
6129 fail:
6130 return NULL;
6131 }
6132
6133
6134 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6135 PyObject *resultobj;
6136 wxRect *arg1 = (wxRect *) 0 ;
6137 int result;
6138 PyObject * obj0 = 0 ;
6139 char *kwnames[] = {
6140 (char *) "self", NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6145 if (SWIG_arg_fail(1)) SWIG_fail;
6146 result = (int) ((arg1)->x);
6147
6148 {
6149 resultobj = SWIG_From_int((int)(result));
6150 }
6151 return resultobj;
6152 fail:
6153 return NULL;
6154 }
6155
6156
6157 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6158 PyObject *resultobj;
6159 wxRect *arg1 = (wxRect *) 0 ;
6160 int arg2 ;
6161 PyObject * obj0 = 0 ;
6162 PyObject * obj1 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self",(char *) "y", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 {
6171 arg2 = (int)(SWIG_As_int(obj1));
6172 if (SWIG_arg_fail(2)) SWIG_fail;
6173 }
6174 if (arg1) (arg1)->y = arg2;
6175
6176 Py_INCREF(Py_None); resultobj = Py_None;
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 int result;
6187 PyObject * obj0 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 result = (int) ((arg1)->y);
6196
6197 {
6198 resultobj = SWIG_From_int((int)(result));
6199 }
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int arg2 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 char *kwnames[] = {
6213 (char *) "self",(char *) "width", NULL
6214 };
6215
6216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6218 if (SWIG_arg_fail(1)) SWIG_fail;
6219 {
6220 arg2 = (int)(SWIG_As_int(obj1));
6221 if (SWIG_arg_fail(2)) SWIG_fail;
6222 }
6223 if (arg1) (arg1)->width = arg2;
6224
6225 Py_INCREF(Py_None); resultobj = Py_None;
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj;
6234 wxRect *arg1 = (wxRect *) 0 ;
6235 int result;
6236 PyObject * obj0 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "self", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 result = (int) ((arg1)->width);
6245
6246 {
6247 resultobj = SWIG_From_int((int)(result));
6248 }
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int arg2 ;
6259 PyObject * obj0 = 0 ;
6260 PyObject * obj1 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self",(char *) "height", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 {
6269 arg2 = (int)(SWIG_As_int(obj1));
6270 if (SWIG_arg_fail(2)) SWIG_fail;
6271 }
6272 if (arg1) (arg1)->height = arg2;
6273
6274 Py_INCREF(Py_None); resultobj = Py_None;
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj;
6283 wxRect *arg1 = (wxRect *) 0 ;
6284 int result;
6285 PyObject * obj0 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "self", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 result = (int) ((arg1)->height);
6294
6295 {
6296 resultobj = SWIG_From_int((int)(result));
6297 }
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int arg2 = (int) 0 ;
6308 int arg3 = (int) 0 ;
6309 int arg4 = (int) 0 ;
6310 int arg5 = (int) 0 ;
6311 PyObject * obj0 = 0 ;
6312 PyObject * obj1 = 0 ;
6313 PyObject * obj2 = 0 ;
6314 PyObject * obj3 = 0 ;
6315 PyObject * obj4 = 0 ;
6316 char *kwnames[] = {
6317 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6318 };
6319
6320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6322 if (SWIG_arg_fail(1)) SWIG_fail;
6323 if (obj1) {
6324 {
6325 arg2 = (int)(SWIG_As_int(obj1));
6326 if (SWIG_arg_fail(2)) SWIG_fail;
6327 }
6328 }
6329 if (obj2) {
6330 {
6331 arg3 = (int)(SWIG_As_int(obj2));
6332 if (SWIG_arg_fail(3)) SWIG_fail;
6333 }
6334 }
6335 if (obj3) {
6336 {
6337 arg4 = (int)(SWIG_As_int(obj3));
6338 if (SWIG_arg_fail(4)) SWIG_fail;
6339 }
6340 }
6341 if (obj4) {
6342 {
6343 arg5 = (int)(SWIG_As_int(obj4));
6344 if (SWIG_arg_fail(5)) SWIG_fail;
6345 }
6346 }
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6350
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 Py_INCREF(Py_None); resultobj = Py_None;
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj;
6363 wxRect *arg1 = (wxRect *) 0 ;
6364 PyObject *result;
6365 PyObject * obj0 = 0 ;
6366 char *kwnames[] = {
6367 (char *) "self", NULL
6368 };
6369
6370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6372 if (SWIG_arg_fail(1)) SWIG_fail;
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (PyObject *)wxRect_Get(arg1);
6376
6377 wxPyEndAllowThreads(__tstate);
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 resultobj = result;
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6388 PyObject *obj;
6389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6390 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6391 Py_INCREF(obj);
6392 return Py_BuildValue((char *)"");
6393 }
6394 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 wxRect *arg2 = (wxRect *) 0 ;
6398 PyObject *result;
6399 PyObject * obj0 = 0 ;
6400 PyObject * obj1 = 0 ;
6401 char *kwnames[] = {
6402 (char *) "r1",(char *) "r2", NULL
6403 };
6404
6405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6409 if (SWIG_arg_fail(2)) SWIG_fail;
6410 {
6411 if (!wxPyCheckForApp()) SWIG_fail;
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 result = (PyObject *)wxIntersectRect(arg1,arg2);
6414
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = result;
6419 return resultobj;
6420 fail:
6421 return NULL;
6422 }
6423
6424
6425 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj;
6427 double arg1 = (double) 0.0 ;
6428 double arg2 = (double) 0.0 ;
6429 wxPoint2D *result;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char *kwnames[] = {
6433 (char *) "x",(char *) "y", NULL
6434 };
6435
6436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6437 if (obj0) {
6438 {
6439 arg1 = (double)(SWIG_As_double(obj0));
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 }
6442 }
6443 if (obj1) {
6444 {
6445 arg2 = (double)(SWIG_As_double(obj1));
6446 if (SWIG_arg_fail(2)) SWIG_fail;
6447 }
6448 }
6449 {
6450 PyThreadState* __tstate = wxPyBeginAllowThreads();
6451 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6452
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6457 return resultobj;
6458 fail:
6459 return NULL;
6460 }
6461
6462
6463 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6464 PyObject *resultobj;
6465 wxPoint2D *arg1 = 0 ;
6466 wxPoint2D *result;
6467 wxPoint2D temp1 ;
6468 PyObject * obj0 = 0 ;
6469 char *kwnames[] = {
6470 (char *) "pt", NULL
6471 };
6472
6473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6474 {
6475 arg1 = &temp1;
6476 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6477 }
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6481
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj;
6494 wxPoint *arg1 = 0 ;
6495 wxPoint2D *result;
6496 wxPoint temp1 ;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "pt", NULL
6500 };
6501
6502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6503 {
6504 arg1 = &temp1;
6505 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6506 }
6507 {
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6510
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj;
6523 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6524 int *arg2 = (int *) 0 ;
6525 int *arg3 = (int *) 0 ;
6526 int temp2 ;
6527 int res2 = 0 ;
6528 int temp3 ;
6529 int res3 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self", NULL
6533 };
6534
6535 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6536 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(1)) SWIG_fail;
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6543
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 Py_INCREF(Py_None); resultobj = Py_None;
6548 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6549 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6550 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6551 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj;
6560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6561 int *arg2 = (int *) 0 ;
6562 int *arg3 = (int *) 0 ;
6563 int temp2 ;
6564 int res2 = 0 ;
6565 int temp3 ;
6566 int res3 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 char *kwnames[] = {
6569 (char *) "self", NULL
6570 };
6571
6572 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6573 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6576 if (SWIG_arg_fail(1)) SWIG_fail;
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6580
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 Py_INCREF(Py_None); resultobj = Py_None;
6585 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6586 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6587 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6588 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj;
6597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6598 double result;
6599 PyObject * obj0 = 0 ;
6600 char *kwnames[] = {
6601 (char *) "self", NULL
6602 };
6603
6604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6606 if (SWIG_arg_fail(1)) SWIG_fail;
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6610
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 {
6615 resultobj = SWIG_From_double((double)(result));
6616 }
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6626 double result;
6627 PyObject * obj0 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self", NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 PyThreadState* __tstate = wxPyBeginAllowThreads();
6637 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6638
6639 wxPyEndAllowThreads(__tstate);
6640 if (PyErr_Occurred()) SWIG_fail;
6641 }
6642 {
6643 resultobj = SWIG_From_double((double)(result));
6644 }
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj;
6653 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6654 double arg2 ;
6655 PyObject * obj0 = 0 ;
6656 PyObject * obj1 = 0 ;
6657 char *kwnames[] = {
6658 (char *) "self",(char *) "length", NULL
6659 };
6660
6661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6663 if (SWIG_arg_fail(1)) SWIG_fail;
6664 {
6665 arg2 = (double)(SWIG_As_double(obj1));
6666 if (SWIG_arg_fail(2)) SWIG_fail;
6667 }
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 (arg1)->SetVectorLength(arg2);
6671
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 Py_INCREF(Py_None); resultobj = Py_None;
6676 return resultobj;
6677 fail:
6678 return NULL;
6679 }
6680
6681
6682 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6683 PyObject *resultobj;
6684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6685 double arg2 ;
6686 PyObject * obj0 = 0 ;
6687 PyObject * obj1 = 0 ;
6688 char *kwnames[] = {
6689 (char *) "self",(char *) "degrees", NULL
6690 };
6691
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6694 if (SWIG_arg_fail(1)) SWIG_fail;
6695 {
6696 arg2 = (double)(SWIG_As_double(obj1));
6697 if (SWIG_arg_fail(2)) SWIG_fail;
6698 }
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 (arg1)->SetVectorAngle(arg2);
6702
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 Py_INCREF(Py_None); resultobj = Py_None;
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj;
6715 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6716 wxPoint2D *arg2 = 0 ;
6717 double result;
6718 wxPoint2D temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char *kwnames[] = {
6722 (char *) "self",(char *) "pt", NULL
6723 };
6724
6725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6727 if (SWIG_arg_fail(1)) SWIG_fail;
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6735
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 {
6740 resultobj = SWIG_From_double((double)(result));
6741 }
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6749 PyObject *resultobj;
6750 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6751 wxPoint2D *arg2 = 0 ;
6752 double result;
6753 wxPoint2D temp2 ;
6754 PyObject * obj0 = 0 ;
6755 PyObject * obj1 = 0 ;
6756 char *kwnames[] = {
6757 (char *) "self",(char *) "pt", NULL
6758 };
6759
6760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6762 if (SWIG_arg_fail(1)) SWIG_fail;
6763 {
6764 arg2 = &temp2;
6765 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6766 }
6767 {
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6770
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = SWIG_From_double((double)(result));
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6784 PyObject *resultobj;
6785 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6786 wxPoint2D *arg2 = 0 ;
6787 double result;
6788 wxPoint2D temp2 ;
6789 PyObject * obj0 = 0 ;
6790 PyObject * obj1 = 0 ;
6791 char *kwnames[] = {
6792 (char *) "self",(char *) "vec", NULL
6793 };
6794
6795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6797 if (SWIG_arg_fail(1)) SWIG_fail;
6798 {
6799 arg2 = &temp2;
6800 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6801 }
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 {
6810 resultobj = SWIG_From_double((double)(result));
6811 }
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj;
6820 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6821 wxPoint2D *arg2 = 0 ;
6822 double result;
6823 wxPoint2D temp2 ;
6824 PyObject * obj0 = 0 ;
6825 PyObject * obj1 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self",(char *) "vec", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 arg2 = &temp2;
6835 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6836 }
6837 {
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6840
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 {
6845 resultobj = SWIG_From_double((double)(result));
6846 }
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj;
6855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6856 wxPoint2D result;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "self", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6864 if (SWIG_arg_fail(1)) SWIG_fail;
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = (arg1)->operator -();
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 wxPoint2D * resultptr;
6874 resultptr = new wxPoint2D((wxPoint2D &)(result));
6875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6876 }
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj;
6885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6886 wxPoint2D *arg2 = 0 ;
6887 wxPoint2D *result;
6888 wxPoint2D temp2 ;
6889 PyObject * obj0 = 0 ;
6890 PyObject * obj1 = 0 ;
6891 char *kwnames[] = {
6892 (char *) "self",(char *) "pt", NULL
6893 };
6894
6895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 {
6899 arg2 = &temp2;
6900 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6901 }
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 {
6905 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6906 result = (wxPoint2D *) &_result_ref;
6907 }
6908
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj;
6921 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6922 wxPoint2D *arg2 = 0 ;
6923 wxPoint2D *result;
6924 wxPoint2D temp2 ;
6925 PyObject * obj0 = 0 ;
6926 PyObject * obj1 = 0 ;
6927 char *kwnames[] = {
6928 (char *) "self",(char *) "pt", NULL
6929 };
6930
6931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6933 if (SWIG_arg_fail(1)) SWIG_fail;
6934 {
6935 arg2 = &temp2;
6936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6937 }
6938 {
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 {
6941 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6942 result = (wxPoint2D *) &_result_ref;
6943 }
6944
6945 wxPyEndAllowThreads(__tstate);
6946 if (PyErr_Occurred()) SWIG_fail;
6947 }
6948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 bool result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7049
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 {
7054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7055 }
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj;
7064 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7065 wxPoint2D *arg2 = 0 ;
7066 bool result;
7067 wxPoint2D temp2 ;
7068 PyObject * obj0 = 0 ;
7069 PyObject * obj1 = 0 ;
7070 char *kwnames[] = {
7071 (char *) "self",(char *) "pt", NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7076 if (SWIG_arg_fail(1)) SWIG_fail;
7077 {
7078 arg2 = &temp2;
7079 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7080 }
7081 {
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7084
7085 wxPyEndAllowThreads(__tstate);
7086 if (PyErr_Occurred()) SWIG_fail;
7087 }
7088 {
7089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7090 }
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7100 double arg2 ;
7101 PyObject * obj0 = 0 ;
7102 PyObject * obj1 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self",(char *) "m_x", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 {
7111 arg2 = (double)(SWIG_As_double(obj1));
7112 if (SWIG_arg_fail(2)) SWIG_fail;
7113 }
7114 if (arg1) (arg1)->m_x = arg2;
7115
7116 Py_INCREF(Py_None); resultobj = Py_None;
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj;
7125 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7126 double result;
7127 PyObject * obj0 = 0 ;
7128 char *kwnames[] = {
7129 (char *) "self", NULL
7130 };
7131
7132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7134 if (SWIG_arg_fail(1)) SWIG_fail;
7135 result = (double) ((arg1)->m_x);
7136
7137 {
7138 resultobj = SWIG_From_double((double)(result));
7139 }
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7149 double arg2 ;
7150 PyObject * obj0 = 0 ;
7151 PyObject * obj1 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self",(char *) "m_y", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 {
7160 arg2 = (double)(SWIG_As_double(obj1));
7161 if (SWIG_arg_fail(2)) SWIG_fail;
7162 }
7163 if (arg1) (arg1)->m_y = arg2;
7164
7165 Py_INCREF(Py_None); resultobj = Py_None;
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj;
7174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7175 double result;
7176 PyObject * obj0 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 result = (double) ((arg1)->m_y);
7185
7186 {
7187 resultobj = SWIG_From_double((double)(result));
7188 }
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double arg2 = (double) 0 ;
7199 double arg3 = (double) 0 ;
7200 PyObject * obj0 = 0 ;
7201 PyObject * obj1 = 0 ;
7202 PyObject * obj2 = 0 ;
7203 char *kwnames[] = {
7204 (char *) "self",(char *) "x",(char *) "y", NULL
7205 };
7206
7207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7209 if (SWIG_arg_fail(1)) SWIG_fail;
7210 if (obj1) {
7211 {
7212 arg2 = (double)(SWIG_As_double(obj1));
7213 if (SWIG_arg_fail(2)) SWIG_fail;
7214 }
7215 }
7216 if (obj2) {
7217 {
7218 arg3 = (double)(SWIG_As_double(obj2));
7219 if (SWIG_arg_fail(3)) SWIG_fail;
7220 }
7221 }
7222 {
7223 PyThreadState* __tstate = wxPyBeginAllowThreads();
7224 wxPoint2D_Set(arg1,arg2,arg3);
7225
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 Py_INCREF(Py_None); resultobj = Py_None;
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj;
7238 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7239 PyObject *result;
7240 PyObject * obj0 = 0 ;
7241 char *kwnames[] = {
7242 (char *) "self", NULL
7243 };
7244
7245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7247 if (SWIG_arg_fail(1)) SWIG_fail;
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 result = (PyObject *)wxPoint2D_Get(arg1);
7251
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = result;
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7263 PyObject *obj;
7264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7265 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7266 Py_INCREF(obj);
7267 return Py_BuildValue((char *)"");
7268 }
7269 static int _wrap_DefaultPosition_set(PyObject *) {
7270 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7271 return 1;
7272 }
7273
7274
7275 static PyObject *_wrap_DefaultPosition_get(void) {
7276 PyObject *pyobj;
7277
7278 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7279 return pyobj;
7280 }
7281
7282
7283 static int _wrap_DefaultSize_set(PyObject *) {
7284 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7285 return 1;
7286 }
7287
7288
7289 static PyObject *_wrap_DefaultSize_get(void) {
7290 PyObject *pyobj;
7291
7292 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7293 return pyobj;
7294 }
7295
7296
7297 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj;
7299 PyObject *arg1 = (PyObject *) 0 ;
7300 wxPyInputStream *result;
7301 PyObject * obj0 = 0 ;
7302 char *kwnames[] = {
7303 (char *) "p", NULL
7304 };
7305
7306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7307 arg1 = obj0;
7308 {
7309 PyThreadState* __tstate = wxPyBeginAllowThreads();
7310 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7311
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj;
7324 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7325 PyObject * obj0 = 0 ;
7326 char *kwnames[] = {
7327 (char *) "self", NULL
7328 };
7329
7330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7332 if (SWIG_arg_fail(1)) SWIG_fail;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 delete arg1;
7336
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 Py_INCREF(Py_None); resultobj = Py_None;
7341 return resultobj;
7342 fail:
7343 return NULL;
7344 }
7345
7346
7347 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7348 PyObject *resultobj;
7349 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 (arg1)->close();
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 Py_INCREF(Py_None); resultobj = Py_None;
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj;
7374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7375 PyObject * obj0 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 (arg1)->flush();
7386
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 Py_INCREF(Py_None); resultobj = Py_None;
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7400 bool result;
7401 PyObject * obj0 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (bool)(arg1)->eof();
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7428 int arg2 = (int) -1 ;
7429 PyObject *result;
7430 PyObject * obj0 = 0 ;
7431 PyObject * obj1 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self",(char *) "size", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(1)) SWIG_fail;
7439 if (obj1) {
7440 {
7441 arg2 = (int)(SWIG_As_int(obj1));
7442 if (SWIG_arg_fail(2)) SWIG_fail;
7443 }
7444 }
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (PyObject *)(arg1)->read(arg2);
7448
7449 wxPyEndAllowThreads(__tstate);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 resultobj = result;
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj;
7461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7462 int arg2 = (int) -1 ;
7463 PyObject *result;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 char *kwnames[] = {
7467 (char *) "self",(char *) "size", NULL
7468 };
7469
7470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7472 if (SWIG_arg_fail(1)) SWIG_fail;
7473 if (obj1) {
7474 {
7475 arg2 = (int)(SWIG_As_int(obj1));
7476 if (SWIG_arg_fail(2)) SWIG_fail;
7477 }
7478 }
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (PyObject *)(arg1)->readline(arg2);
7482
7483 wxPyEndAllowThreads(__tstate);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = result;
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj;
7495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7496 int arg2 = (int) -1 ;
7497 PyObject *result;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char *kwnames[] = {
7501 (char *) "self",(char *) "sizehint", NULL
7502 };
7503
7504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7506 if (SWIG_arg_fail(1)) SWIG_fail;
7507 if (obj1) {
7508 {
7509 arg2 = (int)(SWIG_As_int(obj1));
7510 if (SWIG_arg_fail(2)) SWIG_fail;
7511 }
7512 }
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (PyObject *)(arg1)->readlines(arg2);
7516
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 resultobj = result;
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj;
7529 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7530 int arg2 ;
7531 int arg3 = (int) 0 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 PyObject * obj2 = 0 ;
7535 char *kwnames[] = {
7536 (char *) "self",(char *) "offset",(char *) "whence", NULL
7537 };
7538
7539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7541 if (SWIG_arg_fail(1)) SWIG_fail;
7542 {
7543 arg2 = (int)(SWIG_As_int(obj1));
7544 if (SWIG_arg_fail(2)) SWIG_fail;
7545 }
7546 if (obj2) {
7547 {
7548 arg3 = (int)(SWIG_As_int(obj2));
7549 if (SWIG_arg_fail(3)) SWIG_fail;
7550 }
7551 }
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 (arg1)->seek(arg2,arg3);
7555
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 Py_INCREF(Py_None); resultobj = Py_None;
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7567 PyObject *resultobj;
7568 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7569 int result;
7570 PyObject * obj0 = 0 ;
7571 char *kwnames[] = {
7572 (char *) "self", NULL
7573 };
7574
7575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7577 if (SWIG_arg_fail(1)) SWIG_fail;
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (int)(arg1)->tell();
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 resultobj = SWIG_From_int((int)(result));
7587 }
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7597 char result;
7598 PyObject * obj0 = 0 ;
7599 char *kwnames[] = {
7600 (char *) "self", NULL
7601 };
7602
7603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7605 if (SWIG_arg_fail(1)) SWIG_fail;
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (char)(arg1)->Peek();
7609
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = SWIG_From_char((char)(result));
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 char result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7633 if (SWIG_arg_fail(1)) SWIG_fail;
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 result = (char)(arg1)->GetC();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_char((char)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj;
7652 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7653 size_t result;
7654 PyObject * obj0 = 0 ;
7655 char *kwnames[] = {
7656 (char *) "self", NULL
7657 };
7658
7659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7661 if (SWIG_arg_fail(1)) SWIG_fail;
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 result = (size_t)(arg1)->LastRead();
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 {
7670 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7671 }
7672 return resultobj;
7673 fail:
7674 return NULL;
7675 }
7676
7677
7678 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 bool result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7689 if (SWIG_arg_fail(1)) SWIG_fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (bool)(arg1)->CanRead();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 bool result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 {
7719 PyThreadState* __tstate = wxPyBeginAllowThreads();
7720 result = (bool)(arg1)->Eof();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7737 char arg2 ;
7738 bool result;
7739 PyObject * obj0 = 0 ;
7740 PyObject * obj1 = 0 ;
7741 char *kwnames[] = {
7742 (char *) "self",(char *) "c", NULL
7743 };
7744
7745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7747 if (SWIG_arg_fail(1)) SWIG_fail;
7748 {
7749 arg2 = (char)(SWIG_As_char(obj1));
7750 if (SWIG_arg_fail(2)) SWIG_fail;
7751 }
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (bool)(arg1)->Ungetch(arg2);
7755
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj;
7770 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7771 long arg2 ;
7772 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7773 long result;
7774 PyObject * obj0 = 0 ;
7775 PyObject * obj1 = 0 ;
7776 PyObject * obj2 = 0 ;
7777 char *kwnames[] = {
7778 (char *) "self",(char *) "pos",(char *) "mode", NULL
7779 };
7780
7781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7783 if (SWIG_arg_fail(1)) SWIG_fail;
7784 {
7785 arg2 = (long)(SWIG_As_long(obj1));
7786 if (SWIG_arg_fail(2)) SWIG_fail;
7787 }
7788 if (obj2) {
7789 {
7790 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7791 if (SWIG_arg_fail(3)) SWIG_fail;
7792 }
7793 }
7794 {
7795 PyThreadState* __tstate = wxPyBeginAllowThreads();
7796 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7797
7798 wxPyEndAllowThreads(__tstate);
7799 if (PyErr_Occurred()) SWIG_fail;
7800 }
7801 {
7802 resultobj = SWIG_From_long((long)(result));
7803 }
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj;
7812 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7813 long result;
7814 PyObject * obj0 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (long)(arg1)->TellI();
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 {
7830 resultobj = SWIG_From_long((long)(result));
7831 }
7832 return resultobj;
7833 fail:
7834 return NULL;
7835 }
7836
7837
7838 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7839 PyObject *obj;
7840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7841 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7842 Py_INCREF(obj);
7843 return Py_BuildValue((char *)"");
7844 }
7845 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7848 PyObject *arg2 = (PyObject *) 0 ;
7849 PyObject * obj0 = 0 ;
7850 PyObject * obj1 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self",(char *) "obj", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 arg2 = obj1;
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 wxOutputStream_write(arg1,arg2);
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 Py_INCREF(Py_None); resultobj = Py_None;
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7874 PyObject *obj;
7875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7876 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7877 Py_INCREF(obj);
7878 return Py_BuildValue((char *)"");
7879 }
7880 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7881 PyObject *resultobj;
7882 wxInputStream *arg1 = (wxInputStream *) 0 ;
7883 wxString *arg2 = 0 ;
7884 wxString *arg3 = 0 ;
7885 wxString *arg4 = 0 ;
7886 wxDateTime arg5 ;
7887 wxFSFile *result;
7888 wxPyInputStream *temp1 ;
7889 bool created1 ;
7890 bool temp2 = false ;
7891 bool temp3 = false ;
7892 bool temp4 = false ;
7893 PyObject * obj0 = 0 ;
7894 PyObject * obj1 = 0 ;
7895 PyObject * obj2 = 0 ;
7896 PyObject * obj3 = 0 ;
7897 PyObject * obj4 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7903 {
7904 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7905 arg1 = temp1->m_wxis;
7906 created1 = false;
7907 } else {
7908 PyErr_Clear(); // clear the failure of the wxPyConvert above
7909 arg1 = wxPyCBInputStream_create(obj0, false);
7910 if (arg1 == NULL) {
7911 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7912 SWIG_fail;
7913 }
7914 created1 = true;
7915 }
7916 }
7917 {
7918 arg2 = wxString_in_helper(obj1);
7919 if (arg2 == NULL) SWIG_fail;
7920 temp2 = true;
7921 }
7922 {
7923 arg3 = wxString_in_helper(obj2);
7924 if (arg3 == NULL) SWIG_fail;
7925 temp3 = true;
7926 }
7927 {
7928 arg4 = wxString_in_helper(obj3);
7929 if (arg4 == NULL) SWIG_fail;
7930 temp4 = true;
7931 }
7932 {
7933 wxDateTime * argp;
7934 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7935 if (SWIG_arg_fail(5)) SWIG_fail;
7936 if (argp == NULL) {
7937 SWIG_null_ref("wxDateTime");
7938 }
7939 if (SWIG_arg_fail(5)) SWIG_fail;
7940 arg5 = *argp;
7941 }
7942 {
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7945
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 {
7950 resultobj = wxPyMake_wxObject(result, 1);
7951 }
7952 {
7953 if (created1)
7954 delete arg1;
7955 }
7956 {
7957 if (temp2)
7958 delete arg2;
7959 }
7960 {
7961 if (temp3)
7962 delete arg3;
7963 }
7964 {
7965 if (temp4)
7966 delete arg4;
7967 }
7968 return resultobj;
7969 fail:
7970 {
7971 if (created1)
7972 delete arg1;
7973 }
7974 {
7975 if (temp2)
7976 delete arg2;
7977 }
7978 {
7979 if (temp3)
7980 delete arg3;
7981 }
7982 {
7983 if (temp4)
7984 delete arg4;
7985 }
7986 return NULL;
7987 }
7988
7989
7990 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7991 PyObject *resultobj;
7992 wxFSFile *arg1 = (wxFSFile *) 0 ;
7993 PyObject * obj0 = 0 ;
7994 char *kwnames[] = {
7995 (char *) "self", NULL
7996 };
7997
7998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
7999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8000 if (SWIG_arg_fail(1)) SWIG_fail;
8001 {
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 delete arg1;
8004
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 Py_INCREF(Py_None); resultobj = Py_None;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj;
8017 wxFSFile *arg1 = (wxFSFile *) 0 ;
8018 wxInputStream *result;
8019 PyObject * obj0 = 0 ;
8020 char *kwnames[] = {
8021 (char *) "self", NULL
8022 };
8023
8024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8026 if (SWIG_arg_fail(1)) SWIG_fail;
8027 {
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 result = (wxInputStream *)(arg1)->GetStream();
8030
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 {
8035 wxPyInputStream * _ptr = NULL;
8036
8037 if (result) {
8038 _ptr = new wxPyInputStream(result);
8039 }
8040 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8041 }
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj;
8050 wxFSFile *arg1 = (wxFSFile *) 0 ;
8051 wxString *result;
8052 PyObject * obj0 = 0 ;
8053 char *kwnames[] = {
8054 (char *) "self", NULL
8055 };
8056
8057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8059 if (SWIG_arg_fail(1)) SWIG_fail;
8060 {
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 {
8063 wxString const &_result_ref = (arg1)->GetMimeType();
8064 result = (wxString *) &_result_ref;
8065 }
8066
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 {
8071 #if wxUSE_UNICODE
8072 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8073 #else
8074 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8075 #endif
8076 }
8077 return resultobj;
8078 fail:
8079 return NULL;
8080 }
8081
8082
8083 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8084 PyObject *resultobj;
8085 wxFSFile *arg1 = (wxFSFile *) 0 ;
8086 wxString *result;
8087 PyObject * obj0 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "self", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 {
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 {
8098 wxString const &_result_ref = (arg1)->GetLocation();
8099 result = (wxString *) &_result_ref;
8100 }
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 #if wxUSE_UNICODE
8107 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8108 #else
8109 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8110 #endif
8111 }
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8119 PyObject *resultobj;
8120 wxFSFile *arg1 = (wxFSFile *) 0 ;
8121 wxString *result;
8122 PyObject * obj0 = 0 ;
8123 char *kwnames[] = {
8124 (char *) "self", NULL
8125 };
8126
8127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8129 if (SWIG_arg_fail(1)) SWIG_fail;
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 {
8133 wxString const &_result_ref = (arg1)->GetAnchor();
8134 result = (wxString *) &_result_ref;
8135 }
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 {
8141 #if wxUSE_UNICODE
8142 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8143 #else
8144 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8145 #endif
8146 }
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj;
8155 wxFSFile *arg1 = (wxFSFile *) 0 ;
8156 wxDateTime result;
8157 PyObject * obj0 = 0 ;
8158 char *kwnames[] = {
8159 (char *) "self", NULL
8160 };
8161
8162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8164 if (SWIG_arg_fail(1)) SWIG_fail;
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (arg1)->GetModificationTime();
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 wxDateTime * resultptr;
8174 resultptr = new wxDateTime((wxDateTime &)(result));
8175 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8176 }
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8184 PyObject *obj;
8185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8186 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8187 Py_INCREF(obj);
8188 return Py_BuildValue((char *)"");
8189 }
8190 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8191 PyObject *obj;
8192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8193 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8194 Py_INCREF(obj);
8195 return Py_BuildValue((char *)"");
8196 }
8197 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8198 PyObject *resultobj;
8199 wxPyFileSystemHandler *result;
8200 char *kwnames[] = {
8201 NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8222 PyObject *arg2 = (PyObject *) 0 ;
8223 PyObject *arg3 = (PyObject *) 0 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 PyObject * obj2 = 0 ;
8227 char *kwnames[] = {
8228 (char *) "self",(char *) "self",(char *) "_class", NULL
8229 };
8230
8231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8233 if (SWIG_arg_fail(1)) SWIG_fail;
8234 arg2 = obj1;
8235 arg3 = obj2;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->_setCallbackInfo(arg2,arg3);
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 Py_INCREF(Py_None); resultobj = Py_None;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj;
8252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8253 wxString *arg2 = 0 ;
8254 bool result;
8255 bool temp2 = false ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char *kwnames[] = {
8259 (char *) "self",(char *) "location", NULL
8260 };
8261
8262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8264 if (SWIG_arg_fail(1)) SWIG_fail;
8265 {
8266 arg2 = wxString_in_helper(obj1);
8267 if (arg2 == NULL) SWIG_fail;
8268 temp2 = true;
8269 }
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 {
8278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8279 }
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return resultobj;
8285 fail:
8286 {
8287 if (temp2)
8288 delete arg2;
8289 }
8290 return NULL;
8291 }
8292
8293
8294 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj;
8296 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8297 wxFileSystem *arg2 = 0 ;
8298 wxString *arg3 = 0 ;
8299 wxFSFile *result;
8300 bool temp3 = false ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 PyObject * obj2 = 0 ;
8304 char *kwnames[] = {
8305 (char *) "self",(char *) "fs",(char *) "location", NULL
8306 };
8307
8308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8310 if (SWIG_arg_fail(1)) SWIG_fail;
8311 {
8312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8313 if (SWIG_arg_fail(2)) SWIG_fail;
8314 if (arg2 == NULL) {
8315 SWIG_null_ref("wxFileSystem");
8316 }
8317 if (SWIG_arg_fail(2)) SWIG_fail;
8318 }
8319 {
8320 arg3 = wxString_in_helper(obj2);
8321 if (arg3 == NULL) SWIG_fail;
8322 temp3 = true;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8327
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = wxPyMake_wxObject(result, 1);
8333 }
8334 {
8335 if (temp3)
8336 delete arg3;
8337 }
8338 return resultobj;
8339 fail:
8340 {
8341 if (temp3)
8342 delete arg3;
8343 }
8344 return NULL;
8345 }
8346
8347
8348 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj;
8350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8351 wxString *arg2 = 0 ;
8352 int arg3 = (int) 0 ;
8353 wxString result;
8354 bool temp2 = false ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self",(char *) "spec",(char *) "flags", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 {
8366 arg2 = wxString_in_helper(obj1);
8367 if (arg2 == NULL) SWIG_fail;
8368 temp2 = true;
8369 }
8370 if (obj2) {
8371 {
8372 arg3 = (int)(SWIG_As_int(obj2));
8373 if (SWIG_arg_fail(3)) SWIG_fail;
8374 }
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8379
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 {
8384 #if wxUSE_UNICODE
8385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8386 #else
8387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8388 #endif
8389 }
8390 {
8391 if (temp2)
8392 delete arg2;
8393 }
8394 return resultobj;
8395 fail:
8396 {
8397 if (temp2)
8398 delete arg2;
8399 }
8400 return NULL;
8401 }
8402
8403
8404 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8405 PyObject *resultobj;
8406 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8407 wxString result;
8408 PyObject * obj0 = 0 ;
8409 char *kwnames[] = {
8410 (char *) "self", NULL
8411 };
8412
8413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8415 if (SWIG_arg_fail(1)) SWIG_fail;
8416 {
8417 PyThreadState* __tstate = wxPyBeginAllowThreads();
8418 result = (arg1)->FindNext();
8419
8420 wxPyEndAllowThreads(__tstate);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 {
8424 #if wxUSE_UNICODE
8425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8426 #else
8427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8428 #endif
8429 }
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj;
8438 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8439 wxString *arg2 = 0 ;
8440 wxString result;
8441 bool temp2 = false ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self",(char *) "location", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 {
8452 arg2 = wxString_in_helper(obj1);
8453 if (arg2 == NULL) SWIG_fail;
8454 temp2 = true;
8455 }
8456 {
8457 PyThreadState* __tstate = wxPyBeginAllowThreads();
8458 result = (arg1)->GetProtocol((wxString const &)*arg2);
8459
8460 wxPyEndAllowThreads(__tstate);
8461 if (PyErr_Occurred()) SWIG_fail;
8462 }
8463 {
8464 #if wxUSE_UNICODE
8465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8466 #else
8467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8468 #endif
8469 }
8470 {
8471 if (temp2)
8472 delete arg2;
8473 }
8474 return resultobj;
8475 fail:
8476 {
8477 if (temp2)
8478 delete arg2;
8479 }
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8487 wxString *arg2 = 0 ;
8488 wxString result;
8489 bool temp2 = false ;
8490 PyObject * obj0 = 0 ;
8491 PyObject * obj1 = 0 ;
8492 char *kwnames[] = {
8493 (char *) "self",(char *) "location", NULL
8494 };
8495
8496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8498 if (SWIG_arg_fail(1)) SWIG_fail;
8499 {
8500 arg2 = wxString_in_helper(obj1);
8501 if (arg2 == NULL) SWIG_fail;
8502 temp2 = true;
8503 }
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8507
8508 wxPyEndAllowThreads(__tstate);
8509 if (PyErr_Occurred()) SWIG_fail;
8510 }
8511 {
8512 #if wxUSE_UNICODE
8513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8514 #else
8515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8516 #endif
8517 }
8518 {
8519 if (temp2)
8520 delete arg2;
8521 }
8522 return resultobj;
8523 fail:
8524 {
8525 if (temp2)
8526 delete arg2;
8527 }
8528 return NULL;
8529 }
8530
8531
8532 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj;
8534 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8535 wxString *arg2 = 0 ;
8536 wxString result;
8537 bool temp2 = false ;
8538 PyObject * obj0 = 0 ;
8539 PyObject * obj1 = 0 ;
8540 char *kwnames[] = {
8541 (char *) "self",(char *) "location", NULL
8542 };
8543
8544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8546 if (SWIG_arg_fail(1)) SWIG_fail;
8547 {
8548 arg2 = wxString_in_helper(obj1);
8549 if (arg2 == NULL) SWIG_fail;
8550 temp2 = true;
8551 }
8552 {
8553 PyThreadState* __tstate = wxPyBeginAllowThreads();
8554 result = (arg1)->GetAnchor((wxString const &)*arg2);
8555
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 {
8560 #if wxUSE_UNICODE
8561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8562 #else
8563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8564 #endif
8565 }
8566 {
8567 if (temp2)
8568 delete arg2;
8569 }
8570 return resultobj;
8571 fail:
8572 {
8573 if (temp2)
8574 delete arg2;
8575 }
8576 return NULL;
8577 }
8578
8579
8580 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj;
8582 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8583 wxString *arg2 = 0 ;
8584 wxString result;
8585 bool temp2 = false ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char *kwnames[] = {
8589 (char *) "self",(char *) "location", NULL
8590 };
8591
8592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8594 if (SWIG_arg_fail(1)) SWIG_fail;
8595 {
8596 arg2 = wxString_in_helper(obj1);
8597 if (arg2 == NULL) SWIG_fail;
8598 temp2 = true;
8599 }
8600 {
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 #if wxUSE_UNICODE
8609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8610 #else
8611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8612 #endif
8613 }
8614 {
8615 if (temp2)
8616 delete arg2;
8617 }
8618 return resultobj;
8619 fail:
8620 {
8621 if (temp2)
8622 delete arg2;
8623 }
8624 return NULL;
8625 }
8626
8627
8628 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8629 PyObject *resultobj;
8630 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8631 wxString *arg2 = 0 ;
8632 wxString result;
8633 bool temp2 = false ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char *kwnames[] = {
8637 (char *) "self",(char *) "location", NULL
8638 };
8639
8640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8642 if (SWIG_arg_fail(1)) SWIG_fail;
8643 {
8644 arg2 = wxString_in_helper(obj1);
8645 if (arg2 == NULL) SWIG_fail;
8646 temp2 = true;
8647 }
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8651
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 {
8656 #if wxUSE_UNICODE
8657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8658 #else
8659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8660 #endif
8661 }
8662 {
8663 if (temp2)
8664 delete arg2;
8665 }
8666 return resultobj;
8667 fail:
8668 {
8669 if (temp2)
8670 delete arg2;
8671 }
8672 return NULL;
8673 }
8674
8675
8676 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8677 PyObject *obj;
8678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8679 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8680 Py_INCREF(obj);
8681 return Py_BuildValue((char *)"");
8682 }
8683 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8684 PyObject *resultobj;
8685 wxFileSystem *result;
8686 char *kwnames[] = {
8687 NULL
8688 };
8689
8690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (wxFileSystem *)new wxFileSystem();
8694
8695 wxPyEndAllowThreads(__tstate);
8696 if (PyErr_Occurred()) SWIG_fail;
8697 }
8698 {
8699 resultobj = wxPyMake_wxObject(result, 1);
8700 }
8701 return resultobj;
8702 fail:
8703 return NULL;
8704 }
8705
8706
8707 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8708 PyObject *resultobj;
8709 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8710 PyObject * obj0 = 0 ;
8711 char *kwnames[] = {
8712 (char *) "self", NULL
8713 };
8714
8715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8717 if (SWIG_arg_fail(1)) SWIG_fail;
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 delete arg1;
8721
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 Py_INCREF(Py_None); resultobj = Py_None;
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj;
8734 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8735 wxString *arg2 = 0 ;
8736 bool arg3 = (bool) false ;
8737 bool temp2 = false ;
8738 PyObject * obj0 = 0 ;
8739 PyObject * obj1 = 0 ;
8740 PyObject * obj2 = 0 ;
8741 char *kwnames[] = {
8742 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8743 };
8744
8745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8747 if (SWIG_arg_fail(1)) SWIG_fail;
8748 {
8749 arg2 = wxString_in_helper(obj1);
8750 if (arg2 == NULL) SWIG_fail;
8751 temp2 = true;
8752 }
8753 if (obj2) {
8754 {
8755 arg3 = (bool)(SWIG_As_bool(obj2));
8756 if (SWIG_arg_fail(3)) SWIG_fail;
8757 }
8758 }
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 Py_INCREF(Py_None); resultobj = Py_None;
8767 {
8768 if (temp2)
8769 delete arg2;
8770 }
8771 return resultobj;
8772 fail:
8773 {
8774 if (temp2)
8775 delete arg2;
8776 }
8777 return NULL;
8778 }
8779
8780
8781 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj;
8783 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8784 wxString result;
8785 PyObject * obj0 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "self", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8792 if (SWIG_arg_fail(1)) SWIG_fail;
8793 {
8794 PyThreadState* __tstate = wxPyBeginAllowThreads();
8795 result = (arg1)->GetPath();
8796
8797 wxPyEndAllowThreads(__tstate);
8798 if (PyErr_Occurred()) SWIG_fail;
8799 }
8800 {
8801 #if wxUSE_UNICODE
8802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8803 #else
8804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8805 #endif
8806 }
8807 return resultobj;
8808 fail:
8809 return NULL;
8810 }
8811
8812
8813 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8814 PyObject *resultobj;
8815 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8816 wxString *arg2 = 0 ;
8817 wxFSFile *result;
8818 bool temp2 = false ;
8819 PyObject * obj0 = 0 ;
8820 PyObject * obj1 = 0 ;
8821 char *kwnames[] = {
8822 (char *) "self",(char *) "location", NULL
8823 };
8824
8825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8827 if (SWIG_arg_fail(1)) SWIG_fail;
8828 {
8829 arg2 = wxString_in_helper(obj1);
8830 if (arg2 == NULL) SWIG_fail;
8831 temp2 = true;
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8836
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 {
8841 resultobj = wxPyMake_wxObject(result, 1);
8842 }
8843 {
8844 if (temp2)
8845 delete arg2;
8846 }
8847 return resultobj;
8848 fail:
8849 {
8850 if (temp2)
8851 delete arg2;
8852 }
8853 return NULL;
8854 }
8855
8856
8857 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8858 PyObject *resultobj;
8859 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8860 wxString *arg2 = 0 ;
8861 int arg3 = (int) 0 ;
8862 wxString result;
8863 bool temp2 = false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 PyObject * obj2 = 0 ;
8867 char *kwnames[] = {
8868 (char *) "self",(char *) "spec",(char *) "flags", NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8873 if (SWIG_arg_fail(1)) SWIG_fail;
8874 {
8875 arg2 = wxString_in_helper(obj1);
8876 if (arg2 == NULL) SWIG_fail;
8877 temp2 = true;
8878 }
8879 if (obj2) {
8880 {
8881 arg3 = (int)(SWIG_As_int(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8888
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 {
8893 #if wxUSE_UNICODE
8894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8895 #else
8896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8897 #endif
8898 }
8899 {
8900 if (temp2)
8901 delete arg2;
8902 }
8903 return resultobj;
8904 fail:
8905 {
8906 if (temp2)
8907 delete arg2;
8908 }
8909 return NULL;
8910 }
8911
8912
8913 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj;
8915 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8916 wxString result;
8917 PyObject * obj0 = 0 ;
8918 char *kwnames[] = {
8919 (char *) "self", NULL
8920 };
8921
8922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8924 if (SWIG_arg_fail(1)) SWIG_fail;
8925 {
8926 PyThreadState* __tstate = wxPyBeginAllowThreads();
8927 result = (arg1)->FindNext();
8928
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 {
8933 #if wxUSE_UNICODE
8934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8935 #else
8936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8937 #endif
8938 }
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj;
8947 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8948 PyObject * obj0 = 0 ;
8949 char *kwnames[] = {
8950 (char *) "handler", NULL
8951 };
8952
8953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8955 if (SWIG_arg_fail(1)) SWIG_fail;
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 wxFileSystem::AddHandler(arg1);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 Py_INCREF(Py_None); resultobj = Py_None;
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj;
8972 char *kwnames[] = {
8973 NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 wxFileSystem::CleanUpHandlers();
8980
8981 wxPyEndAllowThreads(__tstate);
8982 if (PyErr_Occurred()) SWIG_fail;
8983 }
8984 Py_INCREF(Py_None); resultobj = Py_None;
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 wxString *arg1 = 0 ;
8994 wxString result;
8995 bool temp1 = false ;
8996 PyObject * obj0 = 0 ;
8997 char *kwnames[] = {
8998 (char *) "filename", NULL
8999 };
9000
9001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9002 {
9003 arg1 = wxString_in_helper(obj0);
9004 if (arg1 == NULL) SWIG_fail;
9005 temp1 = true;
9006 }
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 {
9015 #if wxUSE_UNICODE
9016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9017 #else
9018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9019 #endif
9020 }
9021 {
9022 if (temp1)
9023 delete arg1;
9024 }
9025 return resultobj;
9026 fail:
9027 {
9028 if (temp1)
9029 delete arg1;
9030 }
9031 return NULL;
9032 }
9033
9034
9035 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9036 PyObject *resultobj;
9037 wxString *arg1 = 0 ;
9038 wxString result;
9039 bool temp1 = false ;
9040 PyObject * obj0 = 0 ;
9041 char *kwnames[] = {
9042 (char *) "url", NULL
9043 };
9044
9045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9046 {
9047 arg1 = wxString_in_helper(obj0);
9048 if (arg1 == NULL) SWIG_fail;
9049 temp1 = true;
9050 }
9051 {
9052 PyThreadState* __tstate = wxPyBeginAllowThreads();
9053 result = FileSystem_URLToFileName((wxString const &)*arg1);
9054
9055 wxPyEndAllowThreads(__tstate);
9056 if (PyErr_Occurred()) SWIG_fail;
9057 }
9058 {
9059 #if wxUSE_UNICODE
9060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9061 #else
9062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9063 #endif
9064 }
9065 {
9066 if (temp1)
9067 delete arg1;
9068 }
9069 return resultobj;
9070 fail:
9071 {
9072 if (temp1)
9073 delete arg1;
9074 }
9075 return NULL;
9076 }
9077
9078
9079 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9080 PyObject *obj;
9081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9082 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9083 Py_INCREF(obj);
9084 return Py_BuildValue((char *)"");
9085 }
9086 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj;
9088 wxInternetFSHandler *result;
9089 char *kwnames[] = {
9090 NULL
9091 };
9092
9093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj;
9110 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9111 wxString *arg2 = 0 ;
9112 bool result;
9113 bool temp2 = false ;
9114 PyObject * obj0 = 0 ;
9115 PyObject * obj1 = 0 ;
9116 char *kwnames[] = {
9117 (char *) "self",(char *) "location", NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9122 if (SWIG_arg_fail(1)) SWIG_fail;
9123 {
9124 arg2 = wxString_in_helper(obj1);
9125 if (arg2 == NULL) SWIG_fail;
9126 temp2 = true;
9127 }
9128 {
9129 PyThreadState* __tstate = wxPyBeginAllowThreads();
9130 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9131
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 {
9136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9137 }
9138 {
9139 if (temp2)
9140 delete arg2;
9141 }
9142 return resultobj;
9143 fail:
9144 {
9145 if (temp2)
9146 delete arg2;
9147 }
9148 return NULL;
9149 }
9150
9151
9152 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9155 wxFileSystem *arg2 = 0 ;
9156 wxString *arg3 = 0 ;
9157 wxFSFile *result;
9158 bool temp3 = false ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 PyObject * obj2 = 0 ;
9162 char *kwnames[] = {
9163 (char *) "self",(char *) "fs",(char *) "location", NULL
9164 };
9165
9166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9168 if (SWIG_arg_fail(1)) SWIG_fail;
9169 {
9170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9171 if (SWIG_arg_fail(2)) SWIG_fail;
9172 if (arg2 == NULL) {
9173 SWIG_null_ref("wxFileSystem");
9174 }
9175 if (SWIG_arg_fail(2)) SWIG_fail;
9176 }
9177 {
9178 arg3 = wxString_in_helper(obj2);
9179 if (arg3 == NULL) SWIG_fail;
9180 temp3 = true;
9181 }
9182 {
9183 PyThreadState* __tstate = wxPyBeginAllowThreads();
9184 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9185
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 {
9190 resultobj = wxPyMake_wxObject(result, 1);
9191 }
9192 {
9193 if (temp3)
9194 delete arg3;
9195 }
9196 return resultobj;
9197 fail:
9198 {
9199 if (temp3)
9200 delete arg3;
9201 }
9202 return NULL;
9203 }
9204
9205
9206 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9207 PyObject *obj;
9208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9209 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9210 Py_INCREF(obj);
9211 return Py_BuildValue((char *)"");
9212 }
9213 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxZipFSHandler *result;
9216 char *kwnames[] = {
9217 NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (wxZipFSHandler *)new wxZipFSHandler();
9224
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj;
9237 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9238 wxString *arg2 = 0 ;
9239 bool result;
9240 bool temp2 = false ;
9241 PyObject * obj0 = 0 ;
9242 PyObject * obj1 = 0 ;
9243 char *kwnames[] = {
9244 (char *) "self",(char *) "location", NULL
9245 };
9246
9247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9249 if (SWIG_arg_fail(1)) SWIG_fail;
9250 {
9251 arg2 = wxString_in_helper(obj1);
9252 if (arg2 == NULL) SWIG_fail;
9253 temp2 = true;
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9264 }
9265 {
9266 if (temp2)
9267 delete arg2;
9268 }
9269 return resultobj;
9270 fail:
9271 {
9272 if (temp2)
9273 delete arg2;
9274 }
9275 return NULL;
9276 }
9277
9278
9279 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9282 wxFileSystem *arg2 = 0 ;
9283 wxString *arg3 = 0 ;
9284 wxFSFile *result;
9285 bool temp3 = false ;
9286 PyObject * obj0 = 0 ;
9287 PyObject * obj1 = 0 ;
9288 PyObject * obj2 = 0 ;
9289 char *kwnames[] = {
9290 (char *) "self",(char *) "fs",(char *) "location", NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9295 if (SWIG_arg_fail(1)) SWIG_fail;
9296 {
9297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9298 if (SWIG_arg_fail(2)) SWIG_fail;
9299 if (arg2 == NULL) {
9300 SWIG_null_ref("wxFileSystem");
9301 }
9302 if (SWIG_arg_fail(2)) SWIG_fail;
9303 }
9304 {
9305 arg3 = wxString_in_helper(obj2);
9306 if (arg3 == NULL) SWIG_fail;
9307 temp3 = true;
9308 }
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 {
9317 resultobj = wxPyMake_wxObject(result, 1);
9318 }
9319 {
9320 if (temp3)
9321 delete arg3;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp3)
9327 delete arg3;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9336 wxString *arg2 = 0 ;
9337 int arg3 = (int) 0 ;
9338 wxString result;
9339 bool temp2 = false ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 PyObject * obj2 = 0 ;
9343 char *kwnames[] = {
9344 (char *) "self",(char *) "spec",(char *) "flags", NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9349 if (SWIG_arg_fail(1)) SWIG_fail;
9350 {
9351 arg2 = wxString_in_helper(obj1);
9352 if (arg2 == NULL) SWIG_fail;
9353 temp2 = true;
9354 }
9355 if (obj2) {
9356 {
9357 arg3 = (int)(SWIG_As_int(obj2));
9358 if (SWIG_arg_fail(3)) SWIG_fail;
9359 }
9360 }
9361 {
9362 PyThreadState* __tstate = wxPyBeginAllowThreads();
9363 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9364
9365 wxPyEndAllowThreads(__tstate);
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 {
9369 #if wxUSE_UNICODE
9370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9371 #else
9372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9373 #endif
9374 }
9375 {
9376 if (temp2)
9377 delete arg2;
9378 }
9379 return resultobj;
9380 fail:
9381 {
9382 if (temp2)
9383 delete arg2;
9384 }
9385 return NULL;
9386 }
9387
9388
9389 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9390 PyObject *resultobj;
9391 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9392 wxString result;
9393 PyObject * obj0 = 0 ;
9394 char *kwnames[] = {
9395 (char *) "self", NULL
9396 };
9397
9398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9400 if (SWIG_arg_fail(1)) SWIG_fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (arg1)->FindNext();
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 {
9409 #if wxUSE_UNICODE
9410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9411 #else
9412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9413 #endif
9414 }
9415 return resultobj;
9416 fail:
9417 return NULL;
9418 }
9419
9420
9421 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9422 PyObject *obj;
9423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9424 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9425 Py_INCREF(obj);
9426 return Py_BuildValue((char *)"");
9427 }
9428 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj;
9430 wxString *arg1 = 0 ;
9431 wxImage *arg2 = 0 ;
9432 long arg3 ;
9433 bool temp1 = false ;
9434 PyObject * obj0 = 0 ;
9435 PyObject * obj1 = 0 ;
9436 PyObject * obj2 = 0 ;
9437 char *kwnames[] = {
9438 (char *) "filename",(char *) "image",(char *) "type", NULL
9439 };
9440
9441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9442 {
9443 arg1 = wxString_in_helper(obj0);
9444 if (arg1 == NULL) SWIG_fail;
9445 temp1 = true;
9446 }
9447 {
9448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9449 if (SWIG_arg_fail(2)) SWIG_fail;
9450 if (arg2 == NULL) {
9451 SWIG_null_ref("wxImage");
9452 }
9453 if (SWIG_arg_fail(2)) SWIG_fail;
9454 }
9455 {
9456 arg3 = (long)(SWIG_As_long(obj2));
9457 if (SWIG_arg_fail(3)) SWIG_fail;
9458 }
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9462
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 Py_INCREF(Py_None); resultobj = Py_None;
9467 {
9468 if (temp1)
9469 delete arg1;
9470 }
9471 return resultobj;
9472 fail:
9473 {
9474 if (temp1)
9475 delete arg1;
9476 }
9477 return NULL;
9478 }
9479
9480
9481 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj;
9483 wxString *arg1 = 0 ;
9484 wxBitmap *arg2 = 0 ;
9485 long arg3 ;
9486 bool temp1 = false ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 PyObject * obj2 = 0 ;
9490 char *kwnames[] = {
9491 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9492 };
9493
9494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9495 {
9496 arg1 = wxString_in_helper(obj0);
9497 if (arg1 == NULL) SWIG_fail;
9498 temp1 = true;
9499 }
9500 {
9501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9502 if (SWIG_arg_fail(2)) SWIG_fail;
9503 if (arg2 == NULL) {
9504 SWIG_null_ref("wxBitmap");
9505 }
9506 if (SWIG_arg_fail(2)) SWIG_fail;
9507 }
9508 {
9509 arg3 = (long)(SWIG_As_long(obj2));
9510 if (SWIG_arg_fail(3)) SWIG_fail;
9511 }
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9515
9516 wxPyEndAllowThreads(__tstate);
9517 if (PyErr_Occurred()) SWIG_fail;
9518 }
9519 Py_INCREF(Py_None); resultobj = Py_None;
9520 {
9521 if (temp1)
9522 delete arg1;
9523 }
9524 return resultobj;
9525 fail:
9526 {
9527 if (temp1)
9528 delete arg1;
9529 }
9530 return NULL;
9531 }
9532
9533
9534 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj;
9536 wxString *arg1 = 0 ;
9537 PyObject *arg2 = (PyObject *) 0 ;
9538 bool temp1 = false ;
9539 PyObject * obj0 = 0 ;
9540 PyObject * obj1 = 0 ;
9541 char *kwnames[] = {
9542 (char *) "filename",(char *) "data", NULL
9543 };
9544
9545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9546 {
9547 arg1 = wxString_in_helper(obj0);
9548 if (arg1 == NULL) SWIG_fail;
9549 temp1 = true;
9550 }
9551 arg2 = obj1;
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9555
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 Py_INCREF(Py_None); resultobj = Py_None;
9560 {
9561 if (temp1)
9562 delete arg1;
9563 }
9564 return resultobj;
9565 fail:
9566 {
9567 if (temp1)
9568 delete arg1;
9569 }
9570 return NULL;
9571 }
9572
9573
9574 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9575 PyObject *resultobj;
9576 wxMemoryFSHandler *result;
9577 char *kwnames[] = {
9578 NULL
9579 };
9580
9581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9585
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9597 PyObject *resultobj;
9598 wxString *arg1 = 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 char *kwnames[] = {
9602 (char *) "filename", NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9606 {
9607 arg1 = wxString_in_helper(obj0);
9608 if (arg1 == NULL) SWIG_fail;
9609 temp1 = true;
9610 }
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9614
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 Py_INCREF(Py_None); resultobj = Py_None;
9619 {
9620 if (temp1)
9621 delete arg1;
9622 }
9623 return resultobj;
9624 fail:
9625 {
9626 if (temp1)
9627 delete arg1;
9628 }
9629 return NULL;
9630 }
9631
9632
9633 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj;
9635 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9636 wxString *arg2 = 0 ;
9637 bool result;
9638 bool temp2 = false ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char *kwnames[] = {
9642 (char *) "self",(char *) "location", NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9647 if (SWIG_arg_fail(1)) SWIG_fail;
9648 {
9649 arg2 = wxString_in_helper(obj1);
9650 if (arg2 == NULL) SWIG_fail;
9651 temp2 = true;
9652 }
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 {
9661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9662 }
9663 {
9664 if (temp2)
9665 delete arg2;
9666 }
9667 return resultobj;
9668 fail:
9669 {
9670 if (temp2)
9671 delete arg2;
9672 }
9673 return NULL;
9674 }
9675
9676
9677 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9678 PyObject *resultobj;
9679 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9680 wxFileSystem *arg2 = 0 ;
9681 wxString *arg3 = 0 ;
9682 wxFSFile *result;
9683 bool temp3 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 PyObject * obj2 = 0 ;
9687 char *kwnames[] = {
9688 (char *) "self",(char *) "fs",(char *) "location", NULL
9689 };
9690
9691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9693 if (SWIG_arg_fail(1)) SWIG_fail;
9694 {
9695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(2)) SWIG_fail;
9697 if (arg2 == NULL) {
9698 SWIG_null_ref("wxFileSystem");
9699 }
9700 if (SWIG_arg_fail(2)) SWIG_fail;
9701 }
9702 {
9703 arg3 = wxString_in_helper(obj2);
9704 if (arg3 == NULL) SWIG_fail;
9705 temp3 = true;
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = wxPyMake_wxObject(result, 1);
9716 }
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 return resultobj;
9722 fail:
9723 {
9724 if (temp3)
9725 delete arg3;
9726 }
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9734 wxString *arg2 = 0 ;
9735 int arg3 = (int) 0 ;
9736 wxString result;
9737 bool temp2 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 PyObject * obj2 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self",(char *) "spec",(char *) "flags", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 arg2 = wxString_in_helper(obj1);
9750 if (arg2 == NULL) SWIG_fail;
9751 temp2 = true;
9752 }
9753 if (obj2) {
9754 {
9755 arg3 = (int)(SWIG_As_int(obj2));
9756 if (SWIG_arg_fail(3)) SWIG_fail;
9757 }
9758 }
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9762
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 {
9767 #if wxUSE_UNICODE
9768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9769 #else
9770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9771 #endif
9772 }
9773 {
9774 if (temp2)
9775 delete arg2;
9776 }
9777 return resultobj;
9778 fail:
9779 {
9780 if (temp2)
9781 delete arg2;
9782 }
9783 return NULL;
9784 }
9785
9786
9787 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj;
9789 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9790 wxString result;
9791 PyObject * obj0 = 0 ;
9792 char *kwnames[] = {
9793 (char *) "self", NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(1)) SWIG_fail;
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = (arg1)->FindNext();
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 {
9807 #if wxUSE_UNICODE
9808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9809 #else
9810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9811 #endif
9812 }
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9820 PyObject *obj;
9821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9822 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9823 Py_INCREF(obj);
9824 return Py_BuildValue((char *)"");
9825 }
9826 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9827 PyObject *resultobj;
9828 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9829 wxString result;
9830 PyObject * obj0 = 0 ;
9831 char *kwnames[] = {
9832 (char *) "self", NULL
9833 };
9834
9835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9837 if (SWIG_arg_fail(1)) SWIG_fail;
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 result = (arg1)->GetName();
9841
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 #if wxUSE_UNICODE
9847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9848 #else
9849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9850 #endif
9851 }
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj;
9860 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9861 wxString result;
9862 PyObject * obj0 = 0 ;
9863 char *kwnames[] = {
9864 (char *) "self", NULL
9865 };
9866
9867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9869 if (SWIG_arg_fail(1)) SWIG_fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->GetExtension();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9893 long result;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "self", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9901 if (SWIG_arg_fail(1)) SWIG_fail;
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (long)(arg1)->GetType();
9905
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 {
9910 resultobj = SWIG_From_long((long)(result));
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9921 wxString result;
9922 PyObject * obj0 = 0 ;
9923 char *kwnames[] = {
9924 (char *) "self", NULL
9925 };
9926
9927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9929 if (SWIG_arg_fail(1)) SWIG_fail;
9930 {
9931 PyThreadState* __tstate = wxPyBeginAllowThreads();
9932 result = (arg1)->GetMimeType();
9933
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 #if wxUSE_UNICODE
9939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9940 #else
9941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9942 #endif
9943 }
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj;
9952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9953 wxString *arg2 = 0 ;
9954 bool result;
9955 bool temp2 = false ;
9956 PyObject * obj0 = 0 ;
9957 PyObject * obj1 = 0 ;
9958 char *kwnames[] = {
9959 (char *) "self",(char *) "name", NULL
9960 };
9961
9962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9964 if (SWIG_arg_fail(1)) SWIG_fail;
9965 {
9966 arg2 = wxString_in_helper(obj1);
9967 if (arg2 == NULL) SWIG_fail;
9968 temp2 = true;
9969 }
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 {
9978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9979 }
9980 {
9981 if (temp2)
9982 delete arg2;
9983 }
9984 return resultobj;
9985 fail:
9986 {
9987 if (temp2)
9988 delete arg2;
9989 }
9990 return NULL;
9991 }
9992
9993
9994 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9995 PyObject *resultobj;
9996 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9997 wxString *arg2 = 0 ;
9998 bool temp2 = false ;
9999 PyObject * obj0 = 0 ;
10000 PyObject * obj1 = 0 ;
10001 char *kwnames[] = {
10002 (char *) "self",(char *) "name", NULL
10003 };
10004
10005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10007 if (SWIG_arg_fail(1)) SWIG_fail;
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 (arg1)->SetName((wxString const &)*arg2);
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 Py_INCREF(Py_None); resultobj = Py_None;
10021 {
10022 if (temp2)
10023 delete arg2;
10024 }
10025 return resultobj;
10026 fail:
10027 {
10028 if (temp2)
10029 delete arg2;
10030 }
10031 return NULL;
10032 }
10033
10034
10035 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10036 PyObject *resultobj;
10037 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10038 wxString *arg2 = 0 ;
10039 bool temp2 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 char *kwnames[] = {
10043 (char *) "self",(char *) "extension", NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10048 if (SWIG_arg_fail(1)) SWIG_fail;
10049 {
10050 arg2 = wxString_in_helper(obj1);
10051 if (arg2 == NULL) SWIG_fail;
10052 temp2 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 (arg1)->SetExtension((wxString const &)*arg2);
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 Py_INCREF(Py_None); resultobj = Py_None;
10062 {
10063 if (temp2)
10064 delete arg2;
10065 }
10066 return resultobj;
10067 fail:
10068 {
10069 if (temp2)
10070 delete arg2;
10071 }
10072 return NULL;
10073 }
10074
10075
10076 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10077 PyObject *resultobj;
10078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10079 long arg2 ;
10080 PyObject * obj0 = 0 ;
10081 PyObject * obj1 = 0 ;
10082 char *kwnames[] = {
10083 (char *) "self",(char *) "type", NULL
10084 };
10085
10086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10088 if (SWIG_arg_fail(1)) SWIG_fail;
10089 {
10090 arg2 = (long)(SWIG_As_long(obj1));
10091 if (SWIG_arg_fail(2)) SWIG_fail;
10092 }
10093 {
10094 PyThreadState* __tstate = wxPyBeginAllowThreads();
10095 (arg1)->SetType(arg2);
10096
10097 wxPyEndAllowThreads(__tstate);
10098 if (PyErr_Occurred()) SWIG_fail;
10099 }
10100 Py_INCREF(Py_None); resultobj = Py_None;
10101 return resultobj;
10102 fail:
10103 return NULL;
10104 }
10105
10106
10107 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10108 PyObject *resultobj;
10109 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10110 wxString *arg2 = 0 ;
10111 bool temp2 = false ;
10112 PyObject * obj0 = 0 ;
10113 PyObject * obj1 = 0 ;
10114 char *kwnames[] = {
10115 (char *) "self",(char *) "mimetype", NULL
10116 };
10117
10118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10120 if (SWIG_arg_fail(1)) SWIG_fail;
10121 {
10122 arg2 = wxString_in_helper(obj1);
10123 if (arg2 == NULL) SWIG_fail;
10124 temp2 = true;
10125 }
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 (arg1)->SetMimeType((wxString const &)*arg2);
10129
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 Py_INCREF(Py_None); resultobj = Py_None;
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp2)
10142 delete arg2;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10149 PyObject *obj;
10150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10151 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10152 Py_INCREF(obj);
10153 return Py_BuildValue((char *)"");
10154 }
10155 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10156 PyObject *resultobj;
10157 wxImageHistogram *result;
10158 char *kwnames[] = {
10159 NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10163 {
10164 PyThreadState* __tstate = wxPyBeginAllowThreads();
10165 result = (wxImageHistogram *)new wxImageHistogram();
10166
10167 wxPyEndAllowThreads(__tstate);
10168 if (PyErr_Occurred()) SWIG_fail;
10169 }
10170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj;
10179 unsigned char arg1 ;
10180 unsigned char arg2 ;
10181 unsigned char arg3 ;
10182 unsigned long result;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 PyObject * obj2 = 0 ;
10186 char *kwnames[] = {
10187 (char *) "r",(char *) "g",(char *) "b", NULL
10188 };
10189
10190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10191 {
10192 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10193 if (SWIG_arg_fail(1)) SWIG_fail;
10194 }
10195 {
10196 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10197 if (SWIG_arg_fail(2)) SWIG_fail;
10198 }
10199 {
10200 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10201 if (SWIG_arg_fail(3)) SWIG_fail;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10206
10207 wxPyEndAllowThreads(__tstate);
10208 if (PyErr_Occurred()) SWIG_fail;
10209 }
10210 {
10211 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10212 }
10213 return resultobj;
10214 fail:
10215 return NULL;
10216 }
10217
10218
10219 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10220 PyObject *resultobj;
10221 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10222 unsigned char *arg2 = (unsigned char *) 0 ;
10223 unsigned char *arg3 = (unsigned char *) 0 ;
10224 unsigned char *arg4 = (unsigned char *) 0 ;
10225 unsigned char arg5 = (unsigned char) 1 ;
10226 unsigned char arg6 = (unsigned char) 0 ;
10227 unsigned char arg7 = (unsigned char) 0 ;
10228 bool result;
10229 unsigned char temp2 ;
10230 int res2 = 0 ;
10231 unsigned char temp3 ;
10232 int res3 = 0 ;
10233 unsigned char temp4 ;
10234 int res4 = 0 ;
10235 PyObject * obj0 = 0 ;
10236 PyObject * obj1 = 0 ;
10237 PyObject * obj2 = 0 ;
10238 PyObject * obj3 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10241 };
10242
10243 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10244 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10245 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10248 if (SWIG_arg_fail(1)) SWIG_fail;
10249 if (obj1) {
10250 {
10251 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10252 if (SWIG_arg_fail(5)) SWIG_fail;
10253 }
10254 }
10255 if (obj2) {
10256 {
10257 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10258 if (SWIG_arg_fail(6)) SWIG_fail;
10259 }
10260 }
10261 if (obj3) {
10262 {
10263 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10264 if (SWIG_arg_fail(7)) SWIG_fail;
10265 }
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10270
10271 wxPyEndAllowThreads(__tstate);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 {
10275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10276 }
10277 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10278 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10279 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10281 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10282 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10283 return resultobj;
10284 fail:
10285 return NULL;
10286 }
10287
10288
10289 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10290 PyObject *obj;
10291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10292 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10293 Py_INCREF(obj);
10294 return Py_BuildValue((char *)"");
10295 }
10296 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10297 PyObject *resultobj;
10298 wxString *arg1 = 0 ;
10299 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10300 int arg3 = (int) -1 ;
10301 wxImage *result;
10302 bool temp1 = false ;
10303 PyObject * obj0 = 0 ;
10304 PyObject * obj1 = 0 ;
10305 PyObject * obj2 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "name",(char *) "type",(char *) "index", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10311 {
10312 arg1 = wxString_in_helper(obj0);
10313 if (arg1 == NULL) SWIG_fail;
10314 temp1 = true;
10315 }
10316 if (obj1) {
10317 {
10318 arg2 = (long)(SWIG_As_long(obj1));
10319 if (SWIG_arg_fail(2)) SWIG_fail;
10320 }
10321 }
10322 if (obj2) {
10323 {
10324 arg3 = (int)(SWIG_As_int(obj2));
10325 if (SWIG_arg_fail(3)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10336 {
10337 if (temp1)
10338 delete arg1;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImage *arg1 = (wxImage *) 0 ;
10353 PyObject * obj0 = 0 ;
10354 char *kwnames[] = {
10355 (char *) "self", NULL
10356 };
10357
10358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10360 if (SWIG_arg_fail(1)) SWIG_fail;
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 delete arg1;
10364
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 Py_INCREF(Py_None); resultobj = Py_None;
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj;
10377 wxString *arg1 = 0 ;
10378 wxString *arg2 = 0 ;
10379 int arg3 = (int) -1 ;
10380 wxImage *result;
10381 bool temp1 = false ;
10382 bool temp2 = false ;
10383 PyObject * obj0 = 0 ;
10384 PyObject * obj1 = 0 ;
10385 PyObject * obj2 = 0 ;
10386 char *kwnames[] = {
10387 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10388 };
10389
10390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10391 {
10392 arg1 = wxString_in_helper(obj0);
10393 if (arg1 == NULL) SWIG_fail;
10394 temp1 = true;
10395 }
10396 {
10397 arg2 = wxString_in_helper(obj1);
10398 if (arg2 == NULL) SWIG_fail;
10399 temp2 = true;
10400 }
10401 if (obj2) {
10402 {
10403 arg3 = (int)(SWIG_As_int(obj2));
10404 if (SWIG_arg_fail(3)) SWIG_fail;
10405 }
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10410
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10415 {
10416 if (temp1)
10417 delete arg1;
10418 }
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return resultobj;
10424 fail:
10425 {
10426 if (temp1)
10427 delete arg1;
10428 }
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return NULL;
10434 }
10435
10436
10437 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10438 PyObject *resultobj;
10439 wxInputStream *arg1 = 0 ;
10440 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10441 int arg3 = (int) -1 ;
10442 wxImage *result;
10443 wxPyInputStream *temp1 ;
10444 bool created1 ;
10445 PyObject * obj0 = 0 ;
10446 PyObject * obj1 = 0 ;
10447 PyObject * obj2 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "stream",(char *) "type",(char *) "index", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10453 {
10454 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10455 arg1 = temp1->m_wxis;
10456 created1 = false;
10457 } else {
10458 PyErr_Clear(); // clear the failure of the wxPyConvert above
10459 arg1 = wxPyCBInputStream_create(obj0, false);
10460 if (arg1 == NULL) {
10461 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10462 SWIG_fail;
10463 }
10464 created1 = true;
10465 }
10466 }
10467 if (obj1) {
10468 {
10469 arg2 = (long)(SWIG_As_long(obj1));
10470 if (SWIG_arg_fail(2)) SWIG_fail;
10471 }
10472 }
10473 if (obj2) {
10474 {
10475 arg3 = (int)(SWIG_As_int(obj2));
10476 if (SWIG_arg_fail(3)) SWIG_fail;
10477 }
10478 }
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10482
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10487 {
10488 if (created1)
10489 delete arg1;
10490 }
10491 return resultobj;
10492 fail:
10493 {
10494 if (created1)
10495 delete arg1;
10496 }
10497 return NULL;
10498 }
10499
10500
10501 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10502 PyObject *resultobj;
10503 wxInputStream *arg1 = 0 ;
10504 wxString *arg2 = 0 ;
10505 int arg3 = (int) -1 ;
10506 wxImage *result;
10507 wxPyInputStream *temp1 ;
10508 bool created1 ;
10509 bool temp2 = false ;
10510 PyObject * obj0 = 0 ;
10511 PyObject * obj1 = 0 ;
10512 PyObject * obj2 = 0 ;
10513 char *kwnames[] = {
10514 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10515 };
10516
10517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10518 {
10519 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10520 arg1 = temp1->m_wxis;
10521 created1 = false;
10522 } else {
10523 PyErr_Clear(); // clear the failure of the wxPyConvert above
10524 arg1 = wxPyCBInputStream_create(obj0, false);
10525 if (arg1 == NULL) {
10526 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10527 SWIG_fail;
10528 }
10529 created1 = true;
10530 }
10531 }
10532 {
10533 arg2 = wxString_in_helper(obj1);
10534 if (arg2 == NULL) SWIG_fail;
10535 temp2 = true;
10536 }
10537 if (obj2) {
10538 {
10539 arg3 = (int)(SWIG_As_int(obj2));
10540 if (SWIG_arg_fail(3)) SWIG_fail;
10541 }
10542 }
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10546
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10551 {
10552 if (created1)
10553 delete arg1;
10554 }
10555 {
10556 if (temp2)
10557 delete arg2;
10558 }
10559 return resultobj;
10560 fail:
10561 {
10562 if (created1)
10563 delete arg1;
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return NULL;
10570 }
10571
10572
10573 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10574 PyObject *resultobj;
10575 int arg1 = (int) 0 ;
10576 int arg2 = (int) 0 ;
10577 bool arg3 = (bool) true ;
10578 wxImage *result;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 PyObject * obj2 = 0 ;
10582 char *kwnames[] = {
10583 (char *) "width",(char *) "height",(char *) "clear", NULL
10584 };
10585
10586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10587 if (obj0) {
10588 {
10589 arg1 = (int)(SWIG_As_int(obj0));
10590 if (SWIG_arg_fail(1)) SWIG_fail;
10591 }
10592 }
10593 if (obj1) {
10594 {
10595 arg2 = (int)(SWIG_As_int(obj1));
10596 if (SWIG_arg_fail(2)) SWIG_fail;
10597 }
10598 }
10599 if (obj2) {
10600 {
10601 arg3 = (bool)(SWIG_As_bool(obj2));
10602 if (SWIG_arg_fail(3)) SWIG_fail;
10603 }
10604 }
10605 {
10606 PyThreadState* __tstate = wxPyBeginAllowThreads();
10607 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10608
10609 wxPyEndAllowThreads(__tstate);
10610 if (PyErr_Occurred()) SWIG_fail;
10611 }
10612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10613 return resultobj;
10614 fail:
10615 return NULL;
10616 }
10617
10618
10619 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxBitmap *arg1 = 0 ;
10622 wxImage *result;
10623 PyObject * obj0 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "bitmap", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10629 {
10630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 if (arg1 == NULL) {
10633 SWIG_null_ref("wxBitmap");
10634 }
10635 if (SWIG_arg_fail(1)) SWIG_fail;
10636 }
10637 {
10638 if (!wxPyCheckForApp()) SWIG_fail;
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10641
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj;
10654 int arg1 ;
10655 int arg2 ;
10656 unsigned char *arg3 = (unsigned char *) 0 ;
10657 wxImage *result;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "width",(char *) "height",(char *) "data", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10666 {
10667 arg1 = (int)(SWIG_As_int(obj0));
10668 if (SWIG_arg_fail(1)) SWIG_fail;
10669 }
10670 {
10671 arg2 = (int)(SWIG_As_int(obj1));
10672 if (SWIG_arg_fail(2)) SWIG_fail;
10673 }
10674 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(3)) SWIG_fail;
10676 {
10677 PyThreadState* __tstate = wxPyBeginAllowThreads();
10678 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10679
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 int arg1 ;
10693 int arg2 ;
10694 unsigned char *arg3 = (unsigned char *) 0 ;
10695 unsigned char *arg4 = (unsigned char *) 0 ;
10696 wxImage *result;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 PyObject * obj3 = 0 ;
10701 char *kwnames[] = {
10702 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10703 };
10704
10705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10706 {
10707 arg1 = (int)(SWIG_As_int(obj0));
10708 if (SWIG_arg_fail(1)) SWIG_fail;
10709 }
10710 {
10711 arg2 = (int)(SWIG_As_int(obj1));
10712 if (SWIG_arg_fail(2)) SWIG_fail;
10713 }
10714 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10715 if (SWIG_arg_fail(3)) SWIG_fail;
10716 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10717 if (SWIG_arg_fail(4)) SWIG_fail;
10718 {
10719 PyThreadState* __tstate = wxPyBeginAllowThreads();
10720 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10721
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10733 PyObject *resultobj;
10734 wxImage *arg1 = (wxImage *) 0 ;
10735 int arg2 ;
10736 int arg3 ;
10737 PyObject * obj0 = 0 ;
10738 PyObject * obj1 = 0 ;
10739 PyObject * obj2 = 0 ;
10740 char *kwnames[] = {
10741 (char *) "self",(char *) "width",(char *) "height", NULL
10742 };
10743
10744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 {
10748 arg2 = (int)(SWIG_As_int(obj1));
10749 if (SWIG_arg_fail(2)) SWIG_fail;
10750 }
10751 {
10752 arg3 = (int)(SWIG_As_int(obj2));
10753 if (SWIG_arg_fail(3)) SWIG_fail;
10754 }
10755 {
10756 PyThreadState* __tstate = wxPyBeginAllowThreads();
10757 (arg1)->Create(arg2,arg3);
10758
10759 wxPyEndAllowThreads(__tstate);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 Py_INCREF(Py_None); resultobj = Py_None;
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj;
10771 wxImage *arg1 = (wxImage *) 0 ;
10772 PyObject * obj0 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "self", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10779 if (SWIG_arg_fail(1)) SWIG_fail;
10780 {
10781 PyThreadState* __tstate = wxPyBeginAllowThreads();
10782 (arg1)->Destroy();
10783
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 Py_INCREF(Py_None); resultobj = Py_None;
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj;
10796 wxImage *arg1 = (wxImage *) 0 ;
10797 int arg2 ;
10798 int arg3 ;
10799 SwigValueWrapper<wxImage > result;
10800 PyObject * obj0 = 0 ;
10801 PyObject * obj1 = 0 ;
10802 PyObject * obj2 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self",(char *) "width",(char *) "height", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 arg2 = (int)(SWIG_As_int(obj1));
10812 if (SWIG_arg_fail(2)) SWIG_fail;
10813 }
10814 {
10815 arg3 = (int)(SWIG_As_int(obj2));
10816 if (SWIG_arg_fail(3)) SWIG_fail;
10817 }
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 result = (arg1)->Scale(arg2,arg3);
10821
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 {
10826 wxImage * resultptr;
10827 resultptr = new wxImage((wxImage &)(result));
10828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10829 }
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxImage *arg1 = (wxImage *) 0 ;
10839 int arg2 ;
10840 int arg3 ;
10841 SwigValueWrapper<wxImage > result;
10842 PyObject * obj0 = 0 ;
10843 PyObject * obj1 = 0 ;
10844 PyObject * obj2 = 0 ;
10845 char *kwnames[] = {
10846 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10847 };
10848
10849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 {
10853 arg2 = (int)(SWIG_As_int(obj1));
10854 if (SWIG_arg_fail(2)) SWIG_fail;
10855 }
10856 {
10857 arg3 = (int)(SWIG_As_int(obj2));
10858 if (SWIG_arg_fail(3)) SWIG_fail;
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 {
10868 wxImage * resultptr;
10869 resultptr = new wxImage((wxImage &)(result));
10870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxImage *arg1 = (wxImage *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 wxImage *result;
10884 PyObject * obj0 = 0 ;
10885 PyObject * obj1 = 0 ;
10886 PyObject * obj2 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "self",(char *) "width",(char *) "height", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10893 if (SWIG_arg_fail(1)) SWIG_fail;
10894 {
10895 arg2 = (int)(SWIG_As_int(obj1));
10896 if (SWIG_arg_fail(2)) SWIG_fail;
10897 }
10898 {
10899 arg3 = (int)(SWIG_As_int(obj2));
10900 if (SWIG_arg_fail(3)) SWIG_fail;
10901 }
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 {
10905 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10906 result = (wxImage *) &_result_ref;
10907 }
10908
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10913 return resultobj;
10914 fail:
10915 return NULL;
10916 }
10917
10918
10919 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10920 PyObject *resultobj;
10921 wxImage *arg1 = (wxImage *) 0 ;
10922 int arg2 ;
10923 int arg3 ;
10924 unsigned char arg4 ;
10925 unsigned char arg5 ;
10926 unsigned char arg6 ;
10927 PyObject * obj0 = 0 ;
10928 PyObject * obj1 = 0 ;
10929 PyObject * obj2 = 0 ;
10930 PyObject * obj3 = 0 ;
10931 PyObject * obj4 = 0 ;
10932 PyObject * obj5 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 arg2 = (int)(SWIG_As_int(obj1));
10942 if (SWIG_arg_fail(2)) SWIG_fail;
10943 }
10944 {
10945 arg3 = (int)(SWIG_As_int(obj2));
10946 if (SWIG_arg_fail(3)) SWIG_fail;
10947 }
10948 {
10949 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10950 if (SWIG_arg_fail(4)) SWIG_fail;
10951 }
10952 {
10953 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10954 if (SWIG_arg_fail(5)) SWIG_fail;
10955 }
10956 {
10957 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10958 if (SWIG_arg_fail(6)) SWIG_fail;
10959 }
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 Py_INCREF(Py_None); resultobj = Py_None;
10968 return resultobj;
10969 fail:
10970 return NULL;
10971 }
10972
10973
10974 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10975 PyObject *resultobj;
10976 wxImage *arg1 = (wxImage *) 0 ;
10977 int arg2 ;
10978 int arg3 ;
10979 unsigned char result;
10980 PyObject * obj0 = 0 ;
10981 PyObject * obj1 = 0 ;
10982 PyObject * obj2 = 0 ;
10983 char *kwnames[] = {
10984 (char *) "self",(char *) "x",(char *) "y", NULL
10985 };
10986
10987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10989 if (SWIG_arg_fail(1)) SWIG_fail;
10990 {
10991 arg2 = (int)(SWIG_As_int(obj1));
10992 if (SWIG_arg_fail(2)) SWIG_fail;
10993 }
10994 {
10995 arg3 = (int)(SWIG_As_int(obj2));
10996 if (SWIG_arg_fail(3)) SWIG_fail;
10997 }
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxImage *arg1 = (wxImage *) 0 ;
11017 int arg2 ;
11018 int arg3 ;
11019 unsigned char result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "x",(char *) "y", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = (int)(SWIG_As_int(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 {
11035 arg3 = (int)(SWIG_As_int(obj2));
11036 if (SWIG_arg_fail(3)) SWIG_fail;
11037 }
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11047 }
11048 return resultobj;
11049 fail:
11050 return NULL;
11051 }
11052
11053
11054 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11055 PyObject *resultobj;
11056 wxImage *arg1 = (wxImage *) 0 ;
11057 int arg2 ;
11058 int arg3 ;
11059 unsigned char result;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 PyObject * obj2 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self",(char *) "x",(char *) "y", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 arg2 = (int)(SWIG_As_int(obj1));
11072 if (SWIG_arg_fail(2)) SWIG_fail;
11073 }
11074 {
11075 arg3 = (int)(SWIG_As_int(obj2));
11076 if (SWIG_arg_fail(3)) SWIG_fail;
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11081
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 {
11086 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11087 }
11088 return resultobj;
11089 fail:
11090 return NULL;
11091 }
11092
11093
11094 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11095 PyObject *resultobj;
11096 wxImage *arg1 = (wxImage *) 0 ;
11097 int arg2 ;
11098 int arg3 ;
11099 unsigned char arg4 ;
11100 PyObject * obj0 = 0 ;
11101 PyObject * obj1 = 0 ;
11102 PyObject * obj2 = 0 ;
11103 PyObject * obj3 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 arg2 = (int)(SWIG_As_int(obj1));
11113 if (SWIG_arg_fail(2)) SWIG_fail;
11114 }
11115 {
11116 arg3 = (int)(SWIG_As_int(obj2));
11117 if (SWIG_arg_fail(3)) SWIG_fail;
11118 }
11119 {
11120 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11121 if (SWIG_arg_fail(4)) SWIG_fail;
11122 }
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 (arg1)->SetAlpha(arg2,arg3,arg4);
11126
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 Py_INCREF(Py_None); resultobj = Py_None;
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj;
11139 wxImage *arg1 = (wxImage *) 0 ;
11140 int arg2 ;
11141 int arg3 ;
11142 unsigned char result;
11143 PyObject * obj0 = 0 ;
11144 PyObject * obj1 = 0 ;
11145 PyObject * obj2 = 0 ;
11146 char *kwnames[] = {
11147 (char *) "self",(char *) "x",(char *) "y", NULL
11148 };
11149
11150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11152 if (SWIG_arg_fail(1)) SWIG_fail;
11153 {
11154 arg2 = (int)(SWIG_As_int(obj1));
11155 if (SWIG_arg_fail(2)) SWIG_fail;
11156 }
11157 {
11158 arg3 = (int)(SWIG_As_int(obj2));
11159 if (SWIG_arg_fail(3)) SWIG_fail;
11160 }
11161 {
11162 PyThreadState* __tstate = wxPyBeginAllowThreads();
11163 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11164
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 {
11169 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11170 }
11171 return resultobj;
11172 fail:
11173 return NULL;
11174 }
11175
11176
11177 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11178 PyObject *resultobj;
11179 wxImage *arg1 = (wxImage *) 0 ;
11180 bool result;
11181 PyObject * obj0 = 0 ;
11182 char *kwnames[] = {
11183 (char *) "self", NULL
11184 };
11185
11186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11188 if (SWIG_arg_fail(1)) SWIG_fail;
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 result = (bool)(arg1)->HasAlpha();
11192
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 {
11197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11198 }
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxImage *arg1 = (wxImage *) 0 ;
11208 byte *arg2 = (byte *) 0 ;
11209 byte *arg3 = (byte *) 0 ;
11210 byte *arg4 = (byte *) 0 ;
11211 byte arg5 = (byte) 0 ;
11212 byte arg6 = (byte) 0 ;
11213 byte arg7 = (byte) 0 ;
11214 bool result;
11215 byte temp2 ;
11216 int res2 = 0 ;
11217 byte temp3 ;
11218 int res3 = 0 ;
11219 byte temp4 ;
11220 int res4 = 0 ;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 PyObject * obj3 = 0 ;
11225 char *kwnames[] = {
11226 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11227 };
11228
11229 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11230 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11231 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11234 if (SWIG_arg_fail(1)) SWIG_fail;
11235 if (obj1) {
11236 {
11237 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11238 if (SWIG_arg_fail(5)) SWIG_fail;
11239 }
11240 }
11241 if (obj2) {
11242 {
11243 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11244 if (SWIG_arg_fail(6)) SWIG_fail;
11245 }
11246 }
11247 if (obj3) {
11248 {
11249 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11250 if (SWIG_arg_fail(7)) SWIG_fail;
11251 }
11252 }
11253 {
11254 PyThreadState* __tstate = wxPyBeginAllowThreads();
11255 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11256
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 {
11261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11262 }
11263 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11264 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11265 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11267 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11268 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj;
11277 wxImage *arg1 = (wxImage *) 0 ;
11278 byte arg2 = (byte) 128 ;
11279 bool result;
11280 PyObject * obj0 = 0 ;
11281 PyObject * obj1 = 0 ;
11282 char *kwnames[] = {
11283 (char *) "self",(char *) "threshold", NULL
11284 };
11285
11286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11288 if (SWIG_arg_fail(1)) SWIG_fail;
11289 if (obj1) {
11290 {
11291 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11292 if (SWIG_arg_fail(2)) SWIG_fail;
11293 }
11294 }
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11298
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 {
11303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11304 }
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxImage *arg1 = (wxImage *) 0 ;
11314 unsigned char arg2 ;
11315 unsigned char arg3 ;
11316 unsigned char arg4 ;
11317 bool result;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 PyObject * obj2 = 0 ;
11321 PyObject * obj3 = 0 ;
11322 char *kwnames[] = {
11323 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11324 };
11325
11326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11328 if (SWIG_arg_fail(1)) SWIG_fail;
11329 {
11330 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11331 if (SWIG_arg_fail(2)) SWIG_fail;
11332 }
11333 {
11334 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11335 if (SWIG_arg_fail(3)) SWIG_fail;
11336 }
11337 {
11338 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11339 if (SWIG_arg_fail(4)) SWIG_fail;
11340 }
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11344
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 {
11349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11350 }
11351 return resultobj;
11352 fail:
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj;
11359 wxImage *arg1 = (wxImage *) 0 ;
11360 wxImage *arg2 = 0 ;
11361 byte arg3 ;
11362 byte arg4 ;
11363 byte arg5 ;
11364 bool result;
11365 PyObject * obj0 = 0 ;
11366 PyObject * obj1 = 0 ;
11367 PyObject * obj2 = 0 ;
11368 PyObject * obj3 = 0 ;
11369 PyObject * obj4 = 0 ;
11370 char *kwnames[] = {
11371 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11372 };
11373
11374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11376 if (SWIG_arg_fail(1)) SWIG_fail;
11377 {
11378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11379 if (SWIG_arg_fail(2)) SWIG_fail;
11380 if (arg2 == NULL) {
11381 SWIG_null_ref("wxImage");
11382 }
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11387 if (SWIG_arg_fail(3)) SWIG_fail;
11388 }
11389 {
11390 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11391 if (SWIG_arg_fail(4)) SWIG_fail;
11392 }
11393 {
11394 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11395 if (SWIG_arg_fail(5)) SWIG_fail;
11396 }
11397 {
11398 PyThreadState* __tstate = wxPyBeginAllowThreads();
11399 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11400
11401 wxPyEndAllowThreads(__tstate);
11402 if (PyErr_Occurred()) SWIG_fail;
11403 }
11404 {
11405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11406 }
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj;
11415 wxString *arg1 = 0 ;
11416 bool result;
11417 bool temp1 = false ;
11418 PyObject * obj0 = 0 ;
11419 char *kwnames[] = {
11420 (char *) "name", NULL
11421 };
11422
11423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11424 {
11425 arg1 = wxString_in_helper(obj0);
11426 if (arg1 == NULL) SWIG_fail;
11427 temp1 = true;
11428 }
11429 {
11430 PyThreadState* __tstate = wxPyBeginAllowThreads();
11431 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11432
11433 wxPyEndAllowThreads(__tstate);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 {
11437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11438 }
11439 {
11440 if (temp1)
11441 delete arg1;
11442 }
11443 return resultobj;
11444 fail:
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return NULL;
11450 }
11451
11452
11453 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11454 PyObject *resultobj;
11455 wxString *arg1 = 0 ;
11456 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11457 int result;
11458 bool temp1 = false ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char *kwnames[] = {
11462 (char *) "name",(char *) "type", NULL
11463 };
11464
11465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11466 {
11467 arg1 = wxString_in_helper(obj0);
11468 if (arg1 == NULL) SWIG_fail;
11469 temp1 = true;
11470 }
11471 if (obj1) {
11472 {
11473 arg2 = (long)(SWIG_As_long(obj1));
11474 if (SWIG_arg_fail(2)) SWIG_fail;
11475 }
11476 }
11477 {
11478 PyThreadState* __tstate = wxPyBeginAllowThreads();
11479 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11480
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 {
11485 resultobj = SWIG_From_int((int)(result));
11486 }
11487 {
11488 if (temp1)
11489 delete arg1;
11490 }
11491 return resultobj;
11492 fail:
11493 {
11494 if (temp1)
11495 delete arg1;
11496 }
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxImage *arg1 = (wxImage *) 0 ;
11504 wxString *arg2 = 0 ;
11505 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11506 int arg4 = (int) -1 ;
11507 bool result;
11508 bool temp2 = false ;
11509 PyObject * obj0 = 0 ;
11510 PyObject * obj1 = 0 ;
11511 PyObject * obj2 = 0 ;
11512 PyObject * obj3 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11519 if (SWIG_arg_fail(1)) SWIG_fail;
11520 {
11521 arg2 = wxString_in_helper(obj1);
11522 if (arg2 == NULL) SWIG_fail;
11523 temp2 = true;
11524 }
11525 if (obj2) {
11526 {
11527 arg3 = (long)(SWIG_As_long(obj2));
11528 if (SWIG_arg_fail(3)) SWIG_fail;
11529 }
11530 }
11531 if (obj3) {
11532 {
11533 arg4 = (int)(SWIG_As_int(obj3));
11534 if (SWIG_arg_fail(4)) SWIG_fail;
11535 }
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11540
11541 wxPyEndAllowThreads(__tstate);
11542 if (PyErr_Occurred()) SWIG_fail;
11543 }
11544 {
11545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11546 }
11547 {
11548 if (temp2)
11549 delete arg2;
11550 }
11551 return resultobj;
11552 fail:
11553 {
11554 if (temp2)
11555 delete arg2;
11556 }
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 wxImage *arg1 = (wxImage *) 0 ;
11564 wxString *arg2 = 0 ;
11565 wxString *arg3 = 0 ;
11566 int arg4 = (int) -1 ;
11567 bool result;
11568 bool temp2 = false ;
11569 bool temp3 = false ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 PyObject * obj3 = 0 ;
11574 char *kwnames[] = {
11575 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11576 };
11577
11578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11580 if (SWIG_arg_fail(1)) SWIG_fail;
11581 {
11582 arg2 = wxString_in_helper(obj1);
11583 if (arg2 == NULL) SWIG_fail;
11584 temp2 = true;
11585 }
11586 {
11587 arg3 = wxString_in_helper(obj2);
11588 if (arg3 == NULL) SWIG_fail;
11589 temp3 = true;
11590 }
11591 if (obj3) {
11592 {
11593 arg4 = (int)(SWIG_As_int(obj3));
11594 if (SWIG_arg_fail(4)) SWIG_fail;
11595 }
11596 }
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11600
11601 wxPyEndAllowThreads(__tstate);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 }
11604 {
11605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11606 }
11607 {
11608 if (temp2)
11609 delete arg2;
11610 }
11611 {
11612 if (temp3)
11613 delete arg3;
11614 }
11615 return resultobj;
11616 fail:
11617 {
11618 if (temp2)
11619 delete arg2;
11620 }
11621 {
11622 if (temp3)
11623 delete arg3;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj;
11631 wxImage *arg1 = (wxImage *) 0 ;
11632 wxString *arg2 = 0 ;
11633 int arg3 ;
11634 bool result;
11635 bool temp2 = false ;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 PyObject * obj2 = 0 ;
11639 char *kwnames[] = {
11640 (char *) "self",(char *) "name",(char *) "type", NULL
11641 };
11642
11643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11645 if (SWIG_arg_fail(1)) SWIG_fail;
11646 {
11647 arg2 = wxString_in_helper(obj1);
11648 if (arg2 == NULL) SWIG_fail;
11649 temp2 = true;
11650 }
11651 {
11652 arg3 = (int)(SWIG_As_int(obj2));
11653 if (SWIG_arg_fail(3)) SWIG_fail;
11654 }
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11658
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 {
11663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11664 }
11665 {
11666 if (temp2)
11667 delete arg2;
11668 }
11669 return resultobj;
11670 fail:
11671 {
11672 if (temp2)
11673 delete arg2;
11674 }
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 wxString *arg2 = 0 ;
11683 wxString *arg3 = 0 ;
11684 bool result;
11685 bool temp2 = false ;
11686 bool temp3 = false ;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 PyObject * obj2 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 arg2 = wxString_in_helper(obj1);
11699 if (arg2 == NULL) SWIG_fail;
11700 temp2 = true;
11701 }
11702 {
11703 arg3 = wxString_in_helper(obj2);
11704 if (arg3 == NULL) SWIG_fail;
11705 temp3 = true;
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11716 }
11717 {
11718 if (temp2)
11719 delete arg2;
11720 }
11721 {
11722 if (temp3)
11723 delete arg3;
11724 }
11725 return resultobj;
11726 fail:
11727 {
11728 if (temp2)
11729 delete arg2;
11730 }
11731 {
11732 if (temp3)
11733 delete arg3;
11734 }
11735 return NULL;
11736 }
11737
11738
11739 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11740 PyObject *resultobj;
11741 wxInputStream *arg1 = 0 ;
11742 bool result;
11743 wxPyInputStream *temp1 ;
11744 bool created1 ;
11745 PyObject * obj0 = 0 ;
11746 char *kwnames[] = {
11747 (char *) "stream", NULL
11748 };
11749
11750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11751 {
11752 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11753 arg1 = temp1->m_wxis;
11754 created1 = false;
11755 } else {
11756 PyErr_Clear(); // clear the failure of the wxPyConvert above
11757 arg1 = wxPyCBInputStream_create(obj0, false);
11758 if (arg1 == NULL) {
11759 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11760 SWIG_fail;
11761 }
11762 created1 = true;
11763 }
11764 }
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (bool)wxImage::CanRead(*arg1);
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11774 }
11775 {
11776 if (created1)
11777 delete arg1;
11778 }
11779 return resultobj;
11780 fail:
11781 {
11782 if (created1)
11783 delete arg1;
11784 }
11785 return NULL;
11786 }
11787
11788
11789 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11790 PyObject *resultobj;
11791 wxImage *arg1 = (wxImage *) 0 ;
11792 wxInputStream *arg2 = 0 ;
11793 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11794 int arg4 = (int) -1 ;
11795 bool result;
11796 wxPyInputStream *temp2 ;
11797 bool created2 ;
11798 PyObject * obj0 = 0 ;
11799 PyObject * obj1 = 0 ;
11800 PyObject * obj2 = 0 ;
11801 PyObject * obj3 = 0 ;
11802 char *kwnames[] = {
11803 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11804 };
11805
11806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11808 if (SWIG_arg_fail(1)) SWIG_fail;
11809 {
11810 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11811 arg2 = temp2->m_wxis;
11812 created2 = false;
11813 } else {
11814 PyErr_Clear(); // clear the failure of the wxPyConvert above
11815 arg2 = wxPyCBInputStream_create(obj1, false);
11816 if (arg2 == NULL) {
11817 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11818 SWIG_fail;
11819 }
11820 created2 = true;
11821 }
11822 }
11823 if (obj2) {
11824 {
11825 arg3 = (long)(SWIG_As_long(obj2));
11826 if (SWIG_arg_fail(3)) SWIG_fail;
11827 }
11828 }
11829 if (obj3) {
11830 {
11831 arg4 = (int)(SWIG_As_int(obj3));
11832 if (SWIG_arg_fail(4)) SWIG_fail;
11833 }
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 {
11843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11844 }
11845 {
11846 if (created2)
11847 delete arg2;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (created2)
11853 delete arg2;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxImage *arg1 = (wxImage *) 0 ;
11862 wxInputStream *arg2 = 0 ;
11863 wxString *arg3 = 0 ;
11864 int arg4 = (int) -1 ;
11865 bool result;
11866 wxPyInputStream *temp2 ;
11867 bool created2 ;
11868 bool temp3 = false ;
11869 PyObject * obj0 = 0 ;
11870 PyObject * obj1 = 0 ;
11871 PyObject * obj2 = 0 ;
11872 PyObject * obj3 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11882 arg2 = temp2->m_wxis;
11883 created2 = false;
11884 } else {
11885 PyErr_Clear(); // clear the failure of the wxPyConvert above
11886 arg2 = wxPyCBInputStream_create(obj1, false);
11887 if (arg2 == NULL) {
11888 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11889 SWIG_fail;
11890 }
11891 created2 = true;
11892 }
11893 }
11894 {
11895 arg3 = wxString_in_helper(obj2);
11896 if (arg3 == NULL) SWIG_fail;
11897 temp3 = true;
11898 }
11899 if (obj3) {
11900 {
11901 arg4 = (int)(SWIG_As_int(obj3));
11902 if (SWIG_arg_fail(4)) SWIG_fail;
11903 }
11904 }
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11908
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 {
11913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11914 }
11915 {
11916 if (created2)
11917 delete arg2;
11918 }
11919 {
11920 if (temp3)
11921 delete arg3;
11922 }
11923 return resultobj;
11924 fail:
11925 {
11926 if (created2)
11927 delete arg2;
11928 }
11929 {
11930 if (temp3)
11931 delete arg3;
11932 }
11933 return NULL;
11934 }
11935
11936
11937 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11938 PyObject *resultobj;
11939 wxImage *arg1 = (wxImage *) 0 ;
11940 bool result;
11941 PyObject * obj0 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (bool)(arg1)->Ok();
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj;
11967 wxImage *arg1 = (wxImage *) 0 ;
11968 int result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (int)(arg1)->GetWidth();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = SWIG_From_int((int)(result));
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxImage *arg1 = (wxImage *) 0 ;
11996 int result;
11997 PyObject * obj0 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (int)(arg1)->GetHeight();
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = SWIG_From_int((int)(result));
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxImage *arg1 = (wxImage *) 0 ;
12024 wxSize result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = wxImage_GetSize(arg1);
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 wxSize * resultptr;
12042 resultptr = new wxSize((wxSize &)(result));
12043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12044 }
12045 return resultobj;
12046 fail:
12047 return NULL;
12048 }
12049
12050
12051 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12052 PyObject *resultobj;
12053 wxImage *arg1 = (wxImage *) 0 ;
12054 wxRect *arg2 = 0 ;
12055 SwigValueWrapper<wxImage > result;
12056 wxRect temp2 ;
12057 PyObject * obj0 = 0 ;
12058 PyObject * obj1 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self",(char *) "rect", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 arg2 = &temp2;
12068 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12069 }
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 wxImage * resultptr;
12079 resultptr = new wxImage((wxImage &)(result));
12080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12081 }
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj;
12090 wxImage *arg1 = (wxImage *) 0 ;
12091 SwigValueWrapper<wxImage > result;
12092 PyObject * obj0 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 result = (arg1)->Copy();
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 {
12108 wxImage * resultptr;
12109 resultptr = new wxImage((wxImage &)(result));
12110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12111 }
12112 return resultobj;
12113 fail:
12114 return NULL;
12115 }
12116
12117
12118 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj;
12120 wxImage *arg1 = (wxImage *) 0 ;
12121 wxImage *arg2 = 0 ;
12122 int arg3 ;
12123 int arg4 ;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 PyObject * obj2 = 0 ;
12127 PyObject * obj3 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12137 if (SWIG_arg_fail(2)) SWIG_fail;
12138 if (arg2 == NULL) {
12139 SWIG_null_ref("wxImage");
12140 }
12141 if (SWIG_arg_fail(2)) SWIG_fail;
12142 }
12143 {
12144 arg3 = (int)(SWIG_As_int(obj2));
12145 if (SWIG_arg_fail(3)) SWIG_fail;
12146 }
12147 {
12148 arg4 = (int)(SWIG_As_int(obj3));
12149 if (SWIG_arg_fail(4)) SWIG_fail;
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 Py_INCREF(Py_None); resultobj = Py_None;
12159 return resultobj;
12160 fail:
12161 return NULL;
12162 }
12163
12164
12165 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12166 PyObject *resultobj;
12167 wxImage *arg1 = (wxImage *) 0 ;
12168 PyObject *result;
12169 PyObject * obj0 = 0 ;
12170 char *kwnames[] = {
12171 (char *) "self", NULL
12172 };
12173
12174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12176 if (SWIG_arg_fail(1)) SWIG_fail;
12177 {
12178 PyThreadState* __tstate = wxPyBeginAllowThreads();
12179 result = (PyObject *)wxImage_GetData(arg1);
12180
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 resultobj = result;
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxImage *arg1 = (wxImage *) 0 ;
12194 PyObject *arg2 = (PyObject *) 0 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self",(char *) "data", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12203 if (SWIG_arg_fail(1)) SWIG_fail;
12204 arg2 = obj1;
12205 {
12206 PyThreadState* __tstate = wxPyBeginAllowThreads();
12207 wxImage_SetData(arg1,arg2);
12208
12209 wxPyEndAllowThreads(__tstate);
12210 if (PyErr_Occurred()) SWIG_fail;
12211 }
12212 Py_INCREF(Py_None); resultobj = Py_None;
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12220 PyObject *resultobj;
12221 wxImage *arg1 = (wxImage *) 0 ;
12222 PyObject *result;
12223 PyObject * obj0 = 0 ;
12224 char *kwnames[] = {
12225 (char *) "self", NULL
12226 };
12227
12228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12230 if (SWIG_arg_fail(1)) SWIG_fail;
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12234
12235 wxPyEndAllowThreads(__tstate);
12236 if (PyErr_Occurred()) SWIG_fail;
12237 }
12238 resultobj = result;
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxImage *arg1 = (wxImage *) 0 ;
12248 PyObject *arg2 = (PyObject *) 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char *kwnames[] = {
12252 (char *) "self",(char *) "data", NULL
12253 };
12254
12255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12257 if (SWIG_arg_fail(1)) SWIG_fail;
12258 arg2 = obj1;
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 wxImage_SetDataBuffer(arg1,arg2);
12262
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 Py_INCREF(Py_None); resultobj = Py_None;
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxImage *arg1 = (wxImage *) 0 ;
12276 PyObject *result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (PyObject *)wxImage_GetAlphaData(arg1);
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 resultobj = result;
12293 return resultobj;
12294 fail:
12295 return NULL;
12296 }
12297
12298
12299 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj;
12301 wxImage *arg1 = (wxImage *) 0 ;
12302 PyObject *arg2 = (PyObject *) 0 ;
12303 PyObject * obj0 = 0 ;
12304 PyObject * obj1 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self",(char *) "data", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 arg2 = obj1;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 wxImage_SetAlphaData(arg1,arg2);
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 Py_INCREF(Py_None); resultobj = Py_None;
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj;
12329 wxImage *arg1 = (wxImage *) 0 ;
12330 PyObject *result;
12331 PyObject * obj0 = 0 ;
12332 char *kwnames[] = {
12333 (char *) "self", NULL
12334 };
12335
12336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12338 if (SWIG_arg_fail(1)) SWIG_fail;
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12342
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = result;
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12354 PyObject *resultobj;
12355 wxImage *arg1 = (wxImage *) 0 ;
12356 PyObject *arg2 = (PyObject *) 0 ;
12357 PyObject * obj0 = 0 ;
12358 PyObject * obj1 = 0 ;
12359 char *kwnames[] = {
12360 (char *) "self",(char *) "data", NULL
12361 };
12362
12363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12365 if (SWIG_arg_fail(1)) SWIG_fail;
12366 arg2 = obj1;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 wxImage_SetAlphaBuffer(arg1,arg2);
12370
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 Py_INCREF(Py_None); resultobj = Py_None;
12375 return resultobj;
12376 fail:
12377 return NULL;
12378 }
12379
12380
12381 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12382 PyObject *resultobj;
12383 wxImage *arg1 = (wxImage *) 0 ;
12384 unsigned char arg2 ;
12385 unsigned char arg3 ;
12386 unsigned char arg4 ;
12387 PyObject * obj0 = 0 ;
12388 PyObject * obj1 = 0 ;
12389 PyObject * obj2 = 0 ;
12390 PyObject * obj3 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12397 if (SWIG_arg_fail(1)) SWIG_fail;
12398 {
12399 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12400 if (SWIG_arg_fail(2)) SWIG_fail;
12401 }
12402 {
12403 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12404 if (SWIG_arg_fail(3)) SWIG_fail;
12405 }
12406 {
12407 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12408 if (SWIG_arg_fail(4)) SWIG_fail;
12409 }
12410 {
12411 PyThreadState* __tstate = wxPyBeginAllowThreads();
12412 (arg1)->SetMaskColour(arg2,arg3,arg4);
12413
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 Py_INCREF(Py_None); resultobj = Py_None;
12418 return resultobj;
12419 fail:
12420 return NULL;
12421 }
12422
12423
12424 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12425 PyObject *resultobj;
12426 wxImage *arg1 = (wxImage *) 0 ;
12427 unsigned char result;
12428 PyObject * obj0 = 0 ;
12429 char *kwnames[] = {
12430 (char *) "self", NULL
12431 };
12432
12433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12435 if (SWIG_arg_fail(1)) SWIG_fail;
12436 {
12437 PyThreadState* __tstate = wxPyBeginAllowThreads();
12438 result = (unsigned char)(arg1)->GetMaskRed();
12439
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 {
12444 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj;
12454 wxImage *arg1 = (wxImage *) 0 ;
12455 unsigned char result;
12456 PyObject * obj0 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (unsigned char)(arg1)->GetMaskGreen();
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj;
12482 wxImage *arg1 = (wxImage *) 0 ;
12483 unsigned char result;
12484 PyObject * obj0 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (unsigned char)(arg1)->GetMaskBlue();
12495
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 {
12500 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj;
12510 wxImage *arg1 = (wxImage *) 0 ;
12511 bool arg2 = (bool) true ;
12512 PyObject * obj0 = 0 ;
12513 PyObject * obj1 = 0 ;
12514 char *kwnames[] = {
12515 (char *) "self",(char *) "mask", NULL
12516 };
12517
12518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12520 if (SWIG_arg_fail(1)) SWIG_fail;
12521 if (obj1) {
12522 {
12523 arg2 = (bool)(SWIG_As_bool(obj1));
12524 if (SWIG_arg_fail(2)) SWIG_fail;
12525 }
12526 }
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 (arg1)->SetMask(arg2);
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 Py_INCREF(Py_None); resultobj = Py_None;
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj;
12543 wxImage *arg1 = (wxImage *) 0 ;
12544 bool result;
12545 PyObject * obj0 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(1)) SWIG_fail;
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (bool)(arg1)->HasMask();
12556
12557 wxPyEndAllowThreads(__tstate);
12558 if (PyErr_Occurred()) SWIG_fail;
12559 }
12560 {
12561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12562 }
12563 return resultobj;
12564 fail:
12565 return NULL;
12566 }
12567
12568
12569 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12570 PyObject *resultobj;
12571 wxImage *arg1 = (wxImage *) 0 ;
12572 double arg2 ;
12573 wxPoint *arg3 = 0 ;
12574 bool arg4 = (bool) true ;
12575 wxPoint *arg5 = (wxPoint *) NULL ;
12576 SwigValueWrapper<wxImage > result;
12577 wxPoint temp3 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 PyObject * obj2 = 0 ;
12581 PyObject * obj3 = 0 ;
12582 PyObject * obj4 = 0 ;
12583 char *kwnames[] = {
12584 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12585 };
12586
12587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12589 if (SWIG_arg_fail(1)) SWIG_fail;
12590 {
12591 arg2 = (double)(SWIG_As_double(obj1));
12592 if (SWIG_arg_fail(2)) SWIG_fail;
12593 }
12594 {
12595 arg3 = &temp3;
12596 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12597 }
12598 if (obj3) {
12599 {
12600 arg4 = (bool)(SWIG_As_bool(obj3));
12601 if (SWIG_arg_fail(4)) SWIG_fail;
12602 }
12603 }
12604 if (obj4) {
12605 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(5)) SWIG_fail;
12607 }
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 {
12616 wxImage * resultptr;
12617 resultptr = new wxImage((wxImage &)(result));
12618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12619 }
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxImage *arg1 = (wxImage *) 0 ;
12629 bool arg2 = (bool) true ;
12630 SwigValueWrapper<wxImage > result;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self",(char *) "clockwise", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 if (obj1) {
12641 {
12642 arg2 = (bool)(SWIG_As_bool(obj1));
12643 if (SWIG_arg_fail(2)) SWIG_fail;
12644 }
12645 }
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (arg1)->Rotate90(arg2);
12649
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 {
12654 wxImage * resultptr;
12655 resultptr = new wxImage((wxImage &)(result));
12656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12657 }
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12665 PyObject *resultobj;
12666 wxImage *arg1 = (wxImage *) 0 ;
12667 bool arg2 = (bool) true ;
12668 SwigValueWrapper<wxImage > result;
12669 PyObject * obj0 = 0 ;
12670 PyObject * obj1 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self",(char *) "horizontally", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12677 if (SWIG_arg_fail(1)) SWIG_fail;
12678 if (obj1) {
12679 {
12680 arg2 = (bool)(SWIG_As_bool(obj1));
12681 if (SWIG_arg_fail(2)) SWIG_fail;
12682 }
12683 }
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 result = (arg1)->Mirror(arg2);
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 {
12692 wxImage * resultptr;
12693 resultptr = new wxImage((wxImage &)(result));
12694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12695 }
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12703 PyObject *resultobj;
12704 wxImage *arg1 = (wxImage *) 0 ;
12705 unsigned char arg2 ;
12706 unsigned char arg3 ;
12707 unsigned char arg4 ;
12708 unsigned char arg5 ;
12709 unsigned char arg6 ;
12710 unsigned char arg7 ;
12711 PyObject * obj0 = 0 ;
12712 PyObject * obj1 = 0 ;
12713 PyObject * obj2 = 0 ;
12714 PyObject * obj3 = 0 ;
12715 PyObject * obj4 = 0 ;
12716 PyObject * obj5 = 0 ;
12717 PyObject * obj6 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12724 if (SWIG_arg_fail(1)) SWIG_fail;
12725 {
12726 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12727 if (SWIG_arg_fail(2)) SWIG_fail;
12728 }
12729 {
12730 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12731 if (SWIG_arg_fail(3)) SWIG_fail;
12732 }
12733 {
12734 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12735 if (SWIG_arg_fail(4)) SWIG_fail;
12736 }
12737 {
12738 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12739 if (SWIG_arg_fail(5)) SWIG_fail;
12740 }
12741 {
12742 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12743 if (SWIG_arg_fail(6)) SWIG_fail;
12744 }
12745 {
12746 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12747 if (SWIG_arg_fail(7)) SWIG_fail;
12748 }
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12752
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 Py_INCREF(Py_None); resultobj = Py_None;
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxImage *arg1 = (wxImage *) 0 ;
12766 unsigned char arg2 ;
12767 unsigned char arg3 ;
12768 unsigned char arg4 ;
12769 SwigValueWrapper<wxImage > result;
12770 PyObject * obj0 = 0 ;
12771 PyObject * obj1 = 0 ;
12772 PyObject * obj2 = 0 ;
12773 PyObject * obj3 = 0 ;
12774 char *kwnames[] = {
12775 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12776 };
12777
12778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12780 if (SWIG_arg_fail(1)) SWIG_fail;
12781 {
12782 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12783 if (SWIG_arg_fail(2)) SWIG_fail;
12784 }
12785 {
12786 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12787 if (SWIG_arg_fail(3)) SWIG_fail;
12788 }
12789 {
12790 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12791 if (SWIG_arg_fail(4)) SWIG_fail;
12792 }
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12796
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 {
12801 wxImage * resultptr;
12802 resultptr = new wxImage((wxImage &)(result));
12803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12804 }
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj;
12813 wxImage *arg1 = (wxImage *) 0 ;
12814 wxString *arg2 = 0 ;
12815 wxString *arg3 = 0 ;
12816 bool temp2 = false ;
12817 bool temp3 = false ;
12818 PyObject * obj0 = 0 ;
12819 PyObject * obj1 = 0 ;
12820 PyObject * obj2 = 0 ;
12821 char *kwnames[] = {
12822 (char *) "self",(char *) "name",(char *) "value", NULL
12823 };
12824
12825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12827 if (SWIG_arg_fail(1)) SWIG_fail;
12828 {
12829 arg2 = wxString_in_helper(obj1);
12830 if (arg2 == NULL) SWIG_fail;
12831 temp2 = true;
12832 }
12833 {
12834 arg3 = wxString_in_helper(obj2);
12835 if (arg3 == NULL) SWIG_fail;
12836 temp3 = true;
12837 }
12838 {
12839 PyThreadState* __tstate = wxPyBeginAllowThreads();
12840 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12841
12842 wxPyEndAllowThreads(__tstate);
12843 if (PyErr_Occurred()) SWIG_fail;
12844 }
12845 Py_INCREF(Py_None); resultobj = Py_None;
12846 {
12847 if (temp2)
12848 delete arg2;
12849 }
12850 {
12851 if (temp3)
12852 delete arg3;
12853 }
12854 return resultobj;
12855 fail:
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 {
12861 if (temp3)
12862 delete arg3;
12863 }
12864 return NULL;
12865 }
12866
12867
12868 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12869 PyObject *resultobj;
12870 wxImage *arg1 = (wxImage *) 0 ;
12871 wxString *arg2 = 0 ;
12872 int arg3 ;
12873 bool temp2 = false ;
12874 PyObject * obj0 = 0 ;
12875 PyObject * obj1 = 0 ;
12876 PyObject * obj2 = 0 ;
12877 char *kwnames[] = {
12878 (char *) "self",(char *) "name",(char *) "value", NULL
12879 };
12880
12881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12883 if (SWIG_arg_fail(1)) SWIG_fail;
12884 {
12885 arg2 = wxString_in_helper(obj1);
12886 if (arg2 == NULL) SWIG_fail;
12887 temp2 = true;
12888 }
12889 {
12890 arg3 = (int)(SWIG_As_int(obj2));
12891 if (SWIG_arg_fail(3)) SWIG_fail;
12892 }
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 (arg1)->SetOption((wxString const &)*arg2,arg3);
12896
12897 wxPyEndAllowThreads(__tstate);
12898 if (PyErr_Occurred()) SWIG_fail;
12899 }
12900 Py_INCREF(Py_None); resultobj = Py_None;
12901 {
12902 if (temp2)
12903 delete arg2;
12904 }
12905 return resultobj;
12906 fail:
12907 {
12908 if (temp2)
12909 delete arg2;
12910 }
12911 return NULL;
12912 }
12913
12914
12915 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj;
12917 wxImage *arg1 = (wxImage *) 0 ;
12918 wxString *arg2 = 0 ;
12919 wxString result;
12920 bool temp2 = false ;
12921 PyObject * obj0 = 0 ;
12922 PyObject * obj1 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self",(char *) "name", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 arg2 = wxString_in_helper(obj1);
12932 if (arg2 == NULL) SWIG_fail;
12933 temp2 = true;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 {
12943 #if wxUSE_UNICODE
12944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12945 #else
12946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12947 #endif
12948 }
12949 {
12950 if (temp2)
12951 delete arg2;
12952 }
12953 return resultobj;
12954 fail:
12955 {
12956 if (temp2)
12957 delete arg2;
12958 }
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxImage *arg1 = (wxImage *) 0 ;
12966 wxString *arg2 = 0 ;
12967 int result;
12968 bool temp2 = false ;
12969 PyObject * obj0 = 0 ;
12970 PyObject * obj1 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self",(char *) "name", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 arg2 = wxString_in_helper(obj1);
12980 if (arg2 == NULL) SWIG_fail;
12981 temp2 = true;
12982 }
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12986
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 {
12991 resultobj = SWIG_From_int((int)(result));
12992 }
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return resultobj;
12998 fail:
12999 {
13000 if (temp2)
13001 delete arg2;
13002 }
13003 return NULL;
13004 }
13005
13006
13007 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13008 PyObject *resultobj;
13009 wxImage *arg1 = (wxImage *) 0 ;
13010 wxString *arg2 = 0 ;
13011 bool result;
13012 bool temp2 = false ;
13013 PyObject * obj0 = 0 ;
13014 PyObject * obj1 = 0 ;
13015 char *kwnames[] = {
13016 (char *) "self",(char *) "name", NULL
13017 };
13018
13019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13021 if (SWIG_arg_fail(1)) SWIG_fail;
13022 {
13023 arg2 = wxString_in_helper(obj1);
13024 if (arg2 == NULL) SWIG_fail;
13025 temp2 = true;
13026 }
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13036 }
13037 {
13038 if (temp2)
13039 delete arg2;
13040 }
13041 return resultobj;
13042 fail:
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxImage *arg1 = (wxImage *) 0 ;
13054 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13055 unsigned long result;
13056 PyObject * obj0 = 0 ;
13057 PyObject * obj1 = 0 ;
13058 char *kwnames[] = {
13059 (char *) "self",(char *) "stopafter", NULL
13060 };
13061
13062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13064 if (SWIG_arg_fail(1)) SWIG_fail;
13065 if (obj1) {
13066 {
13067 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13068 if (SWIG_arg_fail(2)) SWIG_fail;
13069 }
13070 }
13071 {
13072 PyThreadState* __tstate = wxPyBeginAllowThreads();
13073 result = (unsigned long)(arg1)->CountColours(arg2);
13074
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 {
13079 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13080 }
13081 return resultobj;
13082 fail:
13083 return NULL;
13084 }
13085
13086
13087 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13088 PyObject *resultobj;
13089 wxImage *arg1 = (wxImage *) 0 ;
13090 wxImageHistogram *arg2 = 0 ;
13091 unsigned long result;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "h", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 {
13102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 if (arg2 == NULL) {
13105 SWIG_null_ref("wxImageHistogram");
13106 }
13107 if (SWIG_arg_fail(2)) SWIG_fail;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13112
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 {
13117 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13118 }
13119 return resultobj;
13120 fail:
13121 return NULL;
13122 }
13123
13124
13125 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13126 PyObject *resultobj;
13127 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13128 PyObject * obj0 = 0 ;
13129 char *kwnames[] = {
13130 (char *) "handler", NULL
13131 };
13132
13133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13135 if (SWIG_arg_fail(1)) SWIG_fail;
13136 {
13137 PyThreadState* __tstate = wxPyBeginAllowThreads();
13138 wxImage::AddHandler(arg1);
13139
13140 wxPyEndAllowThreads(__tstate);
13141 if (PyErr_Occurred()) SWIG_fail;
13142 }
13143 Py_INCREF(Py_None); resultobj = Py_None;
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13153 PyObject * obj0 = 0 ;
13154 char *kwnames[] = {
13155 (char *) "handler", NULL
13156 };
13157
13158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13160 if (SWIG_arg_fail(1)) SWIG_fail;
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 wxImage::InsertHandler(arg1);
13164
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 Py_INCREF(Py_None); resultobj = Py_None;
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj;
13177 wxString *arg1 = 0 ;
13178 bool result;
13179 bool temp1 = false ;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "name", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13186 {
13187 arg1 = wxString_in_helper(obj0);
13188 if (arg1 == NULL) SWIG_fail;
13189 temp1 = true;
13190 }
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13194
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 {
13199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13200 }
13201 {
13202 if (temp1)
13203 delete arg1;
13204 }
13205 return resultobj;
13206 fail:
13207 {
13208 if (temp1)
13209 delete arg1;
13210 }
13211 return NULL;
13212 }
13213
13214
13215 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj;
13217 wxString result;
13218 char *kwnames[] = {
13219 NULL
13220 };
13221
13222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = wxImage::GetImageExtWildcard();
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 {
13231 #if wxUSE_UNICODE
13232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13233 #else
13234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13235 #endif
13236 }
13237 return resultobj;
13238 fail:
13239 return NULL;
13240 }
13241
13242
13243 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj;
13245 wxImage *arg1 = (wxImage *) 0 ;
13246 int arg2 = (int) -1 ;
13247 wxBitmap result;
13248 PyObject * obj0 = 0 ;
13249 PyObject * obj1 = 0 ;
13250 char *kwnames[] = {
13251 (char *) "self",(char *) "depth", NULL
13252 };
13253
13254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13256 if (SWIG_arg_fail(1)) SWIG_fail;
13257 if (obj1) {
13258 {
13259 arg2 = (int)(SWIG_As_int(obj1));
13260 if (SWIG_arg_fail(2)) SWIG_fail;
13261 }
13262 }
13263 {
13264 if (!wxPyCheckForApp()) SWIG_fail;
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = wxImage_ConvertToBitmap(arg1,arg2);
13267
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 {
13272 wxBitmap * resultptr;
13273 resultptr = new wxBitmap((wxBitmap &)(result));
13274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13275 }
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj;
13284 wxImage *arg1 = (wxImage *) 0 ;
13285 unsigned char arg2 ;
13286 unsigned char arg3 ;
13287 unsigned char arg4 ;
13288 wxBitmap result;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 PyObject * obj2 = 0 ;
13292 PyObject * obj3 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13302 if (SWIG_arg_fail(2)) SWIG_fail;
13303 }
13304 {
13305 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13306 if (SWIG_arg_fail(3)) SWIG_fail;
13307 }
13308 {
13309 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13310 if (SWIG_arg_fail(4)) SWIG_fail;
13311 }
13312 {
13313 if (!wxPyCheckForApp()) SWIG_fail;
13314 PyThreadState* __tstate = wxPyBeginAllowThreads();
13315 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13316
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 wxBitmap * resultptr;
13322 resultptr = new wxBitmap((wxBitmap &)(result));
13323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13332 PyObject *obj;
13333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13334 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13335 Py_INCREF(obj);
13336 return Py_BuildValue((char *)"");
13337 }
13338 static int _wrap_NullImage_set(PyObject *) {
13339 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13340 return 1;
13341 }
13342
13343
13344 static PyObject *_wrap_NullImage_get(void) {
13345 PyObject *pyobj;
13346
13347 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13348 return pyobj;
13349 }
13350
13351
13352 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13353 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13354 return 1;
13355 }
13356
13357
13358 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13359 PyObject *pyobj;
13360
13361 {
13362 #if wxUSE_UNICODE
13363 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13364 #else
13365 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13366 #endif
13367 }
13368 return pyobj;
13369 }
13370
13371
13372 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13373 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13374 return 1;
13375 }
13376
13377
13378 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13379 PyObject *pyobj;
13380
13381 {
13382 #if wxUSE_UNICODE
13383 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13384 #else
13385 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13386 #endif
13387 }
13388 return pyobj;
13389 }
13390
13391
13392 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13393 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13394 return 1;
13395 }
13396
13397
13398 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13399 PyObject *pyobj;
13400
13401 {
13402 #if wxUSE_UNICODE
13403 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13404 #else
13405 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13406 #endif
13407 }
13408 return pyobj;
13409 }
13410
13411
13412 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13413 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13414 return 1;
13415 }
13416
13417
13418 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13419 PyObject *pyobj;
13420
13421 {
13422 #if wxUSE_UNICODE
13423 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13424 #else
13425 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13426 #endif
13427 }
13428 return pyobj;
13429 }
13430
13431
13432 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13433 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13434 return 1;
13435 }
13436
13437
13438 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13439 PyObject *pyobj;
13440
13441 {
13442 #if wxUSE_UNICODE
13443 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13444 #else
13445 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13446 #endif
13447 }
13448 return pyobj;
13449 }
13450
13451
13452 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 wxBMPHandler *result;
13455 char *kwnames[] = {
13456 NULL
13457 };
13458
13459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 result = (wxBMPHandler *)new wxBMPHandler();
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13475 PyObject *obj;
13476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13477 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13478 Py_INCREF(obj);
13479 return Py_BuildValue((char *)"");
13480 }
13481 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxICOHandler *result;
13484 char *kwnames[] = {
13485 NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (wxICOHandler *)new wxICOHandler();
13492
13493 wxPyEndAllowThreads(__tstate);
13494 if (PyErr_Occurred()) SWIG_fail;
13495 }
13496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13497 return resultobj;
13498 fail:
13499 return NULL;
13500 }
13501
13502
13503 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13504 PyObject *obj;
13505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13506 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13507 Py_INCREF(obj);
13508 return Py_BuildValue((char *)"");
13509 }
13510 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxCURHandler *result;
13513 char *kwnames[] = {
13514 NULL
13515 };
13516
13517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (wxCURHandler *)new wxCURHandler();
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13526 return resultobj;
13527 fail:
13528 return NULL;
13529 }
13530
13531
13532 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13533 PyObject *obj;
13534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13535 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13536 Py_INCREF(obj);
13537 return Py_BuildValue((char *)"");
13538 }
13539 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13540 PyObject *resultobj;
13541 wxANIHandler *result;
13542 char *kwnames[] = {
13543 NULL
13544 };
13545
13546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13547 {
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 result = (wxANIHandler *)new wxANIHandler();
13550
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13562 PyObject *obj;
13563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13564 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13565 Py_INCREF(obj);
13566 return Py_BuildValue((char *)"");
13567 }
13568 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13569 PyObject *resultobj;
13570 wxPNGHandler *result;
13571 char *kwnames[] = {
13572 NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 result = (wxPNGHandler *)new wxPNGHandler();
13579
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13591 PyObject *obj;
13592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13593 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13594 Py_INCREF(obj);
13595 return Py_BuildValue((char *)"");
13596 }
13597 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj;
13599 wxGIFHandler *result;
13600 char *kwnames[] = {
13601 NULL
13602 };
13603
13604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (wxGIFHandler *)new wxGIFHandler();
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13620 PyObject *obj;
13621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13622 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13623 Py_INCREF(obj);
13624 return Py_BuildValue((char *)"");
13625 }
13626 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 wxPCXHandler *result;
13629 char *kwnames[] = {
13630 NULL
13631 };
13632
13633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (wxPCXHandler *)new wxPCXHandler();
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13649 PyObject *obj;
13650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13651 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13652 Py_INCREF(obj);
13653 return Py_BuildValue((char *)"");
13654 }
13655 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13656 PyObject *resultobj;
13657 wxJPEGHandler *result;
13658 char *kwnames[] = {
13659 NULL
13660 };
13661
13662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (wxJPEGHandler *)new wxJPEGHandler();
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13678 PyObject *obj;
13679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13680 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13681 Py_INCREF(obj);
13682 return Py_BuildValue((char *)"");
13683 }
13684 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxPNMHandler *result;
13687 char *kwnames[] = {
13688 NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 result = (wxPNMHandler *)new wxPNMHandler();
13695
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13707 PyObject *obj;
13708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13709 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13710 Py_INCREF(obj);
13711 return Py_BuildValue((char *)"");
13712 }
13713 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13714 PyObject *resultobj;
13715 wxXPMHandler *result;
13716 char *kwnames[] = {
13717 NULL
13718 };
13719
13720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (wxXPMHandler *)new wxXPMHandler();
13724
13725 wxPyEndAllowThreads(__tstate);
13726 if (PyErr_Occurred()) SWIG_fail;
13727 }
13728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13736 PyObject *obj;
13737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13738 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13739 Py_INCREF(obj);
13740 return Py_BuildValue((char *)"");
13741 }
13742 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13743 PyObject *resultobj;
13744 wxTIFFHandler *result;
13745 char *kwnames[] = {
13746 NULL
13747 };
13748
13749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (wxTIFFHandler *)new wxTIFFHandler();
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13758 return resultobj;
13759 fail:
13760 return NULL;
13761 }
13762
13763
13764 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13765 PyObject *obj;
13766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13767 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13768 Py_INCREF(obj);
13769 return Py_BuildValue((char *)"");
13770 }
13771 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj;
13773 wxImage *arg1 = 0 ;
13774 wxImage *arg2 = 0 ;
13775 int arg3 = (int) 236 ;
13776 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13777 bool result;
13778 PyObject * obj0 = 0 ;
13779 PyObject * obj1 = 0 ;
13780 PyObject * obj2 = 0 ;
13781 PyObject * obj3 = 0 ;
13782 char *kwnames[] = {
13783 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13787 {
13788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 if (arg1 == NULL) {
13791 SWIG_null_ref("wxImage");
13792 }
13793 if (SWIG_arg_fail(1)) SWIG_fail;
13794 }
13795 {
13796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13797 if (SWIG_arg_fail(2)) SWIG_fail;
13798 if (arg2 == NULL) {
13799 SWIG_null_ref("wxImage");
13800 }
13801 if (SWIG_arg_fail(2)) SWIG_fail;
13802 }
13803 if (obj2) {
13804 {
13805 arg3 = (int)(SWIG_As_int(obj2));
13806 if (SWIG_arg_fail(3)) SWIG_fail;
13807 }
13808 }
13809 if (obj3) {
13810 {
13811 arg4 = (int)(SWIG_As_int(obj3));
13812 if (SWIG_arg_fail(4)) SWIG_fail;
13813 }
13814 }
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13818
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 {
13823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13824 }
13825 return resultobj;
13826 fail:
13827 return NULL;
13828 }
13829
13830
13831 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13832 PyObject *obj;
13833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13834 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13835 Py_INCREF(obj);
13836 return Py_BuildValue((char *)"");
13837 }
13838 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj;
13840 wxEvtHandler *result;
13841 char *kwnames[] = {
13842 NULL
13843 };
13844
13845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 result = (wxEvtHandler *)new wxEvtHandler();
13849
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13854 return resultobj;
13855 fail:
13856 return NULL;
13857 }
13858
13859
13860 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13861 PyObject *resultobj;
13862 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13863 wxEvtHandler *result;
13864 PyObject * obj0 = 0 ;
13865 char *kwnames[] = {
13866 (char *) "self", NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13871 if (SWIG_arg_fail(1)) SWIG_fail;
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13875
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 {
13880 resultobj = wxPyMake_wxObject(result, 0);
13881 }
13882 return resultobj;
13883 fail:
13884 return NULL;
13885 }
13886
13887
13888 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13889 PyObject *resultobj;
13890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13891 wxEvtHandler *result;
13892 PyObject * obj0 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13903
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 {
13908 resultobj = wxPyMake_wxObject(result, 0);
13909 }
13910 return resultobj;
13911 fail:
13912 return NULL;
13913 }
13914
13915
13916 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj;
13918 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13919 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13920 PyObject * obj0 = 0 ;
13921 PyObject * obj1 = 0 ;
13922 char *kwnames[] = {
13923 (char *) "self",(char *) "handler", NULL
13924 };
13925
13926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(1)) SWIG_fail;
13929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(2)) SWIG_fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 (arg1)->SetNextHandler(arg2);
13934
13935 wxPyEndAllowThreads(__tstate);
13936 if (PyErr_Occurred()) SWIG_fail;
13937 }
13938 Py_INCREF(Py_None); resultobj = Py_None;
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13946 PyObject *resultobj;
13947 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13948 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 char *kwnames[] = {
13952 (char *) "self",(char *) "handler", NULL
13953 };
13954
13955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(1)) SWIG_fail;
13958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(2)) SWIG_fail;
13960 {
13961 PyThreadState* __tstate = wxPyBeginAllowThreads();
13962 (arg1)->SetPreviousHandler(arg2);
13963
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 Py_INCREF(Py_None); resultobj = Py_None;
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13977 bool result;
13978 PyObject * obj0 = 0 ;
13979 char *kwnames[] = {
13980 (char *) "self", NULL
13981 };
13982
13983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13985 if (SWIG_arg_fail(1)) SWIG_fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 result = (bool)(arg1)->GetEvtHandlerEnabled();
13989
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 {
13994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13995 }
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj;
14004 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14005 bool arg2 ;
14006 PyObject * obj0 = 0 ;
14007 PyObject * obj1 = 0 ;
14008 char *kwnames[] = {
14009 (char *) "self",(char *) "enabled", NULL
14010 };
14011
14012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14014 if (SWIG_arg_fail(1)) SWIG_fail;
14015 {
14016 arg2 = (bool)(SWIG_As_bool(obj1));
14017 if (SWIG_arg_fail(2)) SWIG_fail;
14018 }
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 (arg1)->SetEvtHandlerEnabled(arg2);
14022
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 Py_INCREF(Py_None); resultobj = Py_None;
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj;
14035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14036 wxEvent *arg2 = 0 ;
14037 bool result;
14038 PyObject * obj0 = 0 ;
14039 PyObject * obj1 = 0 ;
14040 char *kwnames[] = {
14041 (char *) "self",(char *) "event", NULL
14042 };
14043
14044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 if (arg2 == NULL) {
14051 SWIG_null_ref("wxEvent");
14052 }
14053 if (SWIG_arg_fail(2)) SWIG_fail;
14054 }
14055 {
14056 PyThreadState* __tstate = wxPyBeginAllowThreads();
14057 result = (bool)(arg1)->ProcessEvent(*arg2);
14058
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 {
14063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14064 }
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14072 PyObject *resultobj;
14073 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14074 wxEvent *arg2 = 0 ;
14075 PyObject * obj0 = 0 ;
14076 PyObject * obj1 = 0 ;
14077 char *kwnames[] = {
14078 (char *) "self",(char *) "event", NULL
14079 };
14080
14081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14083 if (SWIG_arg_fail(1)) SWIG_fail;
14084 {
14085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14086 if (SWIG_arg_fail(2)) SWIG_fail;
14087 if (arg2 == NULL) {
14088 SWIG_null_ref("wxEvent");
14089 }
14090 if (SWIG_arg_fail(2)) SWIG_fail;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 (arg1)->AddPendingEvent(*arg2);
14095
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 Py_INCREF(Py_None); resultobj = Py_None;
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj;
14108 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14109 PyObject * obj0 = 0 ;
14110 char *kwnames[] = {
14111 (char *) "self", NULL
14112 };
14113
14114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14116 if (SWIG_arg_fail(1)) SWIG_fail;
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 (arg1)->ProcessPendingEvents();
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 Py_INCREF(Py_None); resultobj = Py_None;
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj;
14133 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14134 int arg2 ;
14135 int arg3 ;
14136 int arg4 ;
14137 PyObject *arg5 = (PyObject *) 0 ;
14138 PyObject * obj0 = 0 ;
14139 PyObject * obj1 = 0 ;
14140 PyObject * obj2 = 0 ;
14141 PyObject * obj3 = 0 ;
14142 PyObject * obj4 = 0 ;
14143 char *kwnames[] = {
14144 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14145 };
14146
14147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14149 if (SWIG_arg_fail(1)) SWIG_fail;
14150 {
14151 arg2 = (int)(SWIG_As_int(obj1));
14152 if (SWIG_arg_fail(2)) SWIG_fail;
14153 }
14154 {
14155 arg3 = (int)(SWIG_As_int(obj2));
14156 if (SWIG_arg_fail(3)) SWIG_fail;
14157 }
14158 {
14159 arg4 = (int)(SWIG_As_int(obj3));
14160 if (SWIG_arg_fail(4)) SWIG_fail;
14161 }
14162 arg5 = obj4;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 Py_INCREF(Py_None); resultobj = Py_None;
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14180 int arg2 ;
14181 int arg3 = (int) -1 ;
14182 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14183 bool result;
14184 PyObject * obj0 = 0 ;
14185 PyObject * obj1 = 0 ;
14186 PyObject * obj2 = 0 ;
14187 PyObject * obj3 = 0 ;
14188 char *kwnames[] = {
14189 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14194 if (SWIG_arg_fail(1)) SWIG_fail;
14195 {
14196 arg2 = (int)(SWIG_As_int(obj1));
14197 if (SWIG_arg_fail(2)) SWIG_fail;
14198 }
14199 if (obj2) {
14200 {
14201 arg3 = (int)(SWIG_As_int(obj2));
14202 if (SWIG_arg_fail(3)) SWIG_fail;
14203 }
14204 }
14205 if (obj3) {
14206 {
14207 arg4 = (wxEventType)(SWIG_As_int(obj3));
14208 if (SWIG_arg_fail(4)) SWIG_fail;
14209 }
14210 }
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14214
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14220 }
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj;
14229 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14230 PyObject *arg2 = (PyObject *) 0 ;
14231 bool arg3 = (bool) true ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 PyObject * obj2 = 0 ;
14235 char *kwnames[] = {
14236 (char *) "self",(char *) "_self",(char *) "incref", NULL
14237 };
14238
14239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14241 if (SWIG_arg_fail(1)) SWIG_fail;
14242 arg2 = obj1;
14243 if (obj2) {
14244 {
14245 arg3 = (bool)(SWIG_As_bool(obj2));
14246 if (SWIG_arg_fail(3)) SWIG_fail;
14247 }
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14252
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 Py_INCREF(Py_None); resultobj = Py_None;
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14264 PyObject *obj;
14265 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14266 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14267 Py_INCREF(obj);
14268 return Py_BuildValue((char *)"");
14269 }
14270 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxEventType result;
14273 char *kwnames[] = {
14274 NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14278 {
14279 PyThreadState* __tstate = wxPyBeginAllowThreads();
14280 result = (wxEventType)wxNewEventType();
14281
14282 wxPyEndAllowThreads(__tstate);
14283 if (PyErr_Occurred()) SWIG_fail;
14284 }
14285 {
14286 resultobj = SWIG_From_int((int)(result));
14287 }
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj;
14296 wxEvent *arg1 = (wxEvent *) 0 ;
14297 PyObject * obj0 = 0 ;
14298 char *kwnames[] = {
14299 (char *) "self", NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14304 if (SWIG_arg_fail(1)) SWIG_fail;
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 delete arg1;
14308
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 Py_INCREF(Py_None); resultobj = Py_None;
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj;
14321 wxEvent *arg1 = (wxEvent *) 0 ;
14322 wxEventType arg2 ;
14323 PyObject * obj0 = 0 ;
14324 PyObject * obj1 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self",(char *) "typ", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 {
14333 arg2 = (wxEventType)(SWIG_As_int(obj1));
14334 if (SWIG_arg_fail(2)) SWIG_fail;
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 (arg1)->SetEventType(arg2);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 Py_INCREF(Py_None); resultobj = Py_None;
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxEvent *arg1 = (wxEvent *) 0 ;
14353 wxEventType result;
14354 PyObject * obj0 = 0 ;
14355 char *kwnames[] = {
14356 (char *) "self", NULL
14357 };
14358
14359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14361 if (SWIG_arg_fail(1)) SWIG_fail;
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14365
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 resultobj = SWIG_From_int((int)(result));
14371 }
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj;
14380 wxEvent *arg1 = (wxEvent *) 0 ;
14381 wxObject *result;
14382 PyObject * obj0 = 0 ;
14383 char *kwnames[] = {
14384 (char *) "self", NULL
14385 };
14386
14387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14389 if (SWIG_arg_fail(1)) SWIG_fail;
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 {
14398 resultobj = wxPyMake_wxObject(result, 0);
14399 }
14400 return resultobj;
14401 fail:
14402 return NULL;
14403 }
14404
14405
14406 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj;
14408 wxEvent *arg1 = (wxEvent *) 0 ;
14409 wxObject *arg2 = (wxObject *) 0 ;
14410 PyObject * obj0 = 0 ;
14411 PyObject * obj1 = 0 ;
14412 char *kwnames[] = {
14413 (char *) "self",(char *) "obj", NULL
14414 };
14415
14416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(1)) SWIG_fail;
14419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(2)) SWIG_fail;
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 (arg1)->SetEventObject(arg2);
14424
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 Py_INCREF(Py_None); resultobj = Py_None;
14429 return resultobj;
14430 fail:
14431 return NULL;
14432 }
14433
14434
14435 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj;
14437 wxEvent *arg1 = (wxEvent *) 0 ;
14438 long result;
14439 PyObject * obj0 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14450
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 {
14455 resultobj = SWIG_From_long((long)(result));
14456 }
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxEvent *arg1 = (wxEvent *) 0 ;
14466 long arg2 = (long) 0 ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char *kwnames[] = {
14470 (char *) "self",(char *) "ts", NULL
14471 };
14472
14473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 if (obj1) {
14477 {
14478 arg2 = (long)(SWIG_As_long(obj1));
14479 if (SWIG_arg_fail(2)) SWIG_fail;
14480 }
14481 }
14482 {
14483 PyThreadState* __tstate = wxPyBeginAllowThreads();
14484 (arg1)->SetTimestamp(arg2);
14485
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 Py_INCREF(Py_None); resultobj = Py_None;
14490 return resultobj;
14491 fail:
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxEvent *arg1 = (wxEvent *) 0 ;
14499 int result;
14500 PyObject * obj0 = 0 ;
14501 char *kwnames[] = {
14502 (char *) "self", NULL
14503 };
14504
14505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14507 if (SWIG_arg_fail(1)) SWIG_fail;
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (int)((wxEvent const *)arg1)->GetId();
14511
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 {
14516 resultobj = SWIG_From_int((int)(result));
14517 }
14518 return resultobj;
14519 fail:
14520 return NULL;
14521 }
14522
14523
14524 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj;
14526 wxEvent *arg1 = (wxEvent *) 0 ;
14527 int arg2 ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 char *kwnames[] = {
14531 (char *) "self",(char *) "Id", NULL
14532 };
14533
14534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
14539 if (SWIG_arg_fail(2)) SWIG_fail;
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 (arg1)->SetId(arg2);
14544
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 Py_INCREF(Py_None); resultobj = Py_None;
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj;
14557 wxEvent *arg1 = (wxEvent *) 0 ;
14558 bool result;
14559 PyObject * obj0 = 0 ;
14560 char *kwnames[] = {
14561 (char *) "self", NULL
14562 };
14563
14564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14566 if (SWIG_arg_fail(1)) SWIG_fail;
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14576 }
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14584 PyObject *resultobj;
14585 wxEvent *arg1 = (wxEvent *) 0 ;
14586 bool arg2 = (bool) true ;
14587 PyObject * obj0 = 0 ;
14588 PyObject * obj1 = 0 ;
14589 char *kwnames[] = {
14590 (char *) "self",(char *) "skip", NULL
14591 };
14592
14593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14595 if (SWIG_arg_fail(1)) SWIG_fail;
14596 if (obj1) {
14597 {
14598 arg2 = (bool)(SWIG_As_bool(obj1));
14599 if (SWIG_arg_fail(2)) SWIG_fail;
14600 }
14601 }
14602 {
14603 PyThreadState* __tstate = wxPyBeginAllowThreads();
14604 (arg1)->Skip(arg2);
14605
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 Py_INCREF(Py_None); resultobj = Py_None;
14610 return resultobj;
14611 fail:
14612 return NULL;
14613 }
14614
14615
14616 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj;
14618 wxEvent *arg1 = (wxEvent *) 0 ;
14619 bool result;
14620 PyObject * obj0 = 0 ;
14621 char *kwnames[] = {
14622 (char *) "self", NULL
14623 };
14624
14625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14627 if (SWIG_arg_fail(1)) SWIG_fail;
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14631
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 {
14636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14637 }
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj;
14646 wxEvent *arg1 = (wxEvent *) 0 ;
14647 bool result;
14648 PyObject * obj0 = 0 ;
14649 char *kwnames[] = {
14650 (char *) "self", NULL
14651 };
14652
14653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14655 if (SWIG_arg_fail(1)) SWIG_fail;
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14659
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 return resultobj;
14667 fail:
14668 return NULL;
14669 }
14670
14671
14672 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14673 PyObject *resultobj;
14674 wxEvent *arg1 = (wxEvent *) 0 ;
14675 int result;
14676 PyObject * obj0 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 result = (int)(arg1)->StopPropagation();
14687
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 {
14692 resultobj = SWIG_From_int((int)(result));
14693 }
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj;
14702 wxEvent *arg1 = (wxEvent *) 0 ;
14703 int arg2 ;
14704 PyObject * obj0 = 0 ;
14705 PyObject * obj1 = 0 ;
14706 char *kwnames[] = {
14707 (char *) "self",(char *) "propagationLevel", NULL
14708 };
14709
14710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14712 if (SWIG_arg_fail(1)) SWIG_fail;
14713 {
14714 arg2 = (int)(SWIG_As_int(obj1));
14715 if (SWIG_arg_fail(2)) SWIG_fail;
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 (arg1)->ResumePropagation(arg2);
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 Py_INCREF(Py_None); resultobj = Py_None;
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxEvent *arg1 = (wxEvent *) 0 ;
14734 wxEvent *result;
14735 PyObject * obj0 = 0 ;
14736 char *kwnames[] = {
14737 (char *) "self", NULL
14738 };
14739
14740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14742 if (SWIG_arg_fail(1)) SWIG_fail;
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 result = (wxEvent *)(arg1)->Clone();
14746
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14758 PyObject *obj;
14759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14760 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14761 Py_INCREF(obj);
14762 return Py_BuildValue((char *)"");
14763 }
14764 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj;
14766 wxEvent *arg1 = 0 ;
14767 wxPropagationDisabler *result;
14768 PyObject * obj0 = 0 ;
14769 char *kwnames[] = {
14770 (char *) "event", NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14774 {
14775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(1)) SWIG_fail;
14777 if (arg1 == NULL) {
14778 SWIG_null_ref("wxEvent");
14779 }
14780 if (SWIG_arg_fail(1)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14799 PyObject * obj0 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 delete arg1;
14810
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 Py_INCREF(Py_None); resultobj = Py_None;
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14822 PyObject *obj;
14823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14824 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14825 Py_INCREF(obj);
14826 return Py_BuildValue((char *)"");
14827 }
14828 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj;
14830 wxEvent *arg1 = 0 ;
14831 wxPropagateOnce *result;
14832 PyObject * obj0 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "event", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14838 {
14839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14840 if (SWIG_arg_fail(1)) SWIG_fail;
14841 if (arg1 == NULL) {
14842 SWIG_null_ref("wxEvent");
14843 }
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 }
14846 {
14847 PyThreadState* __tstate = wxPyBeginAllowThreads();
14848 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14849
14850 wxPyEndAllowThreads(__tstate);
14851 if (PyErr_Occurred()) SWIG_fail;
14852 }
14853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14854 return resultobj;
14855 fail:
14856 return NULL;
14857 }
14858
14859
14860 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14861 PyObject *resultobj;
14862 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14863 PyObject * obj0 = 0 ;
14864 char *kwnames[] = {
14865 (char *) "self", NULL
14866 };
14867
14868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14870 if (SWIG_arg_fail(1)) SWIG_fail;
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 delete arg1;
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 Py_INCREF(Py_None); resultobj = Py_None;
14879 return resultobj;
14880 fail:
14881 return NULL;
14882 }
14883
14884
14885 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14886 PyObject *obj;
14887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14888 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14889 Py_INCREF(obj);
14890 return Py_BuildValue((char *)"");
14891 }
14892 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14893 PyObject *resultobj;
14894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14895 int arg2 = (int) 0 ;
14896 wxCommandEvent *result;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 char *kwnames[] = {
14900 (char *) "commandType",(char *) "winid", NULL
14901 };
14902
14903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14904 if (obj0) {
14905 {
14906 arg1 = (wxEventType)(SWIG_As_int(obj0));
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 }
14909 }
14910 if (obj1) {
14911 {
14912 arg2 = (int)(SWIG_As_int(obj1));
14913 if (SWIG_arg_fail(2)) SWIG_fail;
14914 }
14915 }
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14919
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14933 int result;
14934 PyObject * obj0 = 0 ;
14935 char *kwnames[] = {
14936 (char *) "self", NULL
14937 };
14938
14939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14941 if (SWIG_arg_fail(1)) SWIG_fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 {
14950 resultobj = SWIG_From_int((int)(result));
14951 }
14952 return resultobj;
14953 fail:
14954 return NULL;
14955 }
14956
14957
14958 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj;
14960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14961 wxString *arg2 = 0 ;
14962 bool temp2 = false ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 char *kwnames[] = {
14966 (char *) "self",(char *) "s", NULL
14967 };
14968
14969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14971 if (SWIG_arg_fail(1)) SWIG_fail;
14972 {
14973 arg2 = wxString_in_helper(obj1);
14974 if (arg2 == NULL) SWIG_fail;
14975 temp2 = true;
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 (arg1)->SetString((wxString const &)*arg2);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 Py_INCREF(Py_None); resultobj = Py_None;
14985 {
14986 if (temp2)
14987 delete arg2;
14988 }
14989 return resultobj;
14990 fail:
14991 {
14992 if (temp2)
14993 delete arg2;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15002 wxString result;
15003 PyObject * obj0 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "self", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = ((wxCommandEvent const *)arg1)->GetString();
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 {
15019 #if wxUSE_UNICODE
15020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15021 #else
15022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15023 #endif
15024 }
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj;
15033 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15034 bool result;
15035 PyObject * obj0 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self", NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15042 if (SWIG_arg_fail(1)) SWIG_fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15046
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 {
15051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15052 }
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15060 PyObject *resultobj;
15061 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15062 bool result;
15063 PyObject * obj0 = 0 ;
15064 char *kwnames[] = {
15065 (char *) "self", NULL
15066 };
15067
15068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15070 if (SWIG_arg_fail(1)) SWIG_fail;
15071 {
15072 PyThreadState* __tstate = wxPyBeginAllowThreads();
15073 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15074
15075 wxPyEndAllowThreads(__tstate);
15076 if (PyErr_Occurred()) SWIG_fail;
15077 }
15078 {
15079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15080 }
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15088 PyObject *resultobj;
15089 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15090 long arg2 ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "self",(char *) "extraLong", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15099 if (SWIG_arg_fail(1)) SWIG_fail;
15100 {
15101 arg2 = (long)(SWIG_As_long(obj1));
15102 if (SWIG_arg_fail(2)) SWIG_fail;
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 (arg1)->SetExtraLong(arg2);
15107
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 Py_INCREF(Py_None); resultobj = Py_None;
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15121 long result;
15122 PyObject * obj0 = 0 ;
15123 char *kwnames[] = {
15124 (char *) "self", NULL
15125 };
15126
15127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15129 if (SWIG_arg_fail(1)) SWIG_fail;
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15133
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 {
15138 resultobj = SWIG_From_long((long)(result));
15139 }
15140 return resultobj;
15141 fail:
15142 return NULL;
15143 }
15144
15145
15146 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj;
15148 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15149 int arg2 ;
15150 PyObject * obj0 = 0 ;
15151 PyObject * obj1 = 0 ;
15152 char *kwnames[] = {
15153 (char *) "self",(char *) "i", NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15158 if (SWIG_arg_fail(1)) SWIG_fail;
15159 {
15160 arg2 = (int)(SWIG_As_int(obj1));
15161 if (SWIG_arg_fail(2)) SWIG_fail;
15162 }
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 (arg1)->SetInt(arg2);
15166
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 Py_INCREF(Py_None); resultobj = Py_None;
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15178 PyObject *resultobj;
15179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15180 long result;
15181 PyObject * obj0 = 0 ;
15182 char *kwnames[] = {
15183 (char *) "self", NULL
15184 };
15185
15186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15188 if (SWIG_arg_fail(1)) SWIG_fail;
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 {
15197 resultobj = SWIG_From_long((long)(result));
15198 }
15199 return resultobj;
15200 fail:
15201 return NULL;
15202 }
15203
15204
15205 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj;
15207 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15208 wxEvent *result;
15209 PyObject * obj0 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15220
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15232 PyObject *obj;
15233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15234 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15235 Py_INCREF(obj);
15236 return Py_BuildValue((char *)"");
15237 }
15238 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj;
15240 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15241 int arg2 = (int) 0 ;
15242 wxNotifyEvent *result;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "commandType",(char *) "winid", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15250 if (obj0) {
15251 {
15252 arg1 = (wxEventType)(SWIG_As_int(obj0));
15253 if (SWIG_arg_fail(1)) SWIG_fail;
15254 }
15255 }
15256 if (obj1) {
15257 {
15258 arg2 = (int)(SWIG_As_int(obj1));
15259 if (SWIG_arg_fail(2)) SWIG_fail;
15260 }
15261 }
15262 {
15263 PyThreadState* __tstate = wxPyBeginAllowThreads();
15264 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15265
15266 wxPyEndAllowThreads(__tstate);
15267 if (PyErr_Occurred()) SWIG_fail;
15268 }
15269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15277 PyObject *resultobj;
15278 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15279 PyObject * obj0 = 0 ;
15280 char *kwnames[] = {
15281 (char *) "self", NULL
15282 };
15283
15284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 (arg1)->Veto();
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 Py_INCREF(Py_None); resultobj = Py_None;
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15304 PyObject * obj0 = 0 ;
15305 char *kwnames[] = {
15306 (char *) "self", NULL
15307 };
15308
15309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15311 if (SWIG_arg_fail(1)) SWIG_fail;
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 (arg1)->Allow();
15315
15316 wxPyEndAllowThreads(__tstate);
15317 if (PyErr_Occurred()) SWIG_fail;
15318 }
15319 Py_INCREF(Py_None); resultobj = Py_None;
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15327 PyObject *resultobj;
15328 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15329 bool result;
15330 PyObject * obj0 = 0 ;
15331 char *kwnames[] = {
15332 (char *) "self", NULL
15333 };
15334
15335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15337 if (SWIG_arg_fail(1)) SWIG_fail;
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 result = (bool)(arg1)->IsAllowed();
15341
15342 wxPyEndAllowThreads(__tstate);
15343 if (PyErr_Occurred()) SWIG_fail;
15344 }
15345 {
15346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15347 }
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15355 PyObject *obj;
15356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15357 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15358 Py_INCREF(obj);
15359 return Py_BuildValue((char *)"");
15360 }
15361 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj;
15363 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15364 int arg2 = (int) 0 ;
15365 int arg3 = (int) 0 ;
15366 int arg4 = (int) 0 ;
15367 wxScrollEvent *result;
15368 PyObject * obj0 = 0 ;
15369 PyObject * obj1 = 0 ;
15370 PyObject * obj2 = 0 ;
15371 PyObject * obj3 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15377 if (obj0) {
15378 {
15379 arg1 = (wxEventType)(SWIG_As_int(obj0));
15380 if (SWIG_arg_fail(1)) SWIG_fail;
15381 }
15382 }
15383 if (obj1) {
15384 {
15385 arg2 = (int)(SWIG_As_int(obj1));
15386 if (SWIG_arg_fail(2)) SWIG_fail;
15387 }
15388 }
15389 if (obj2) {
15390 {
15391 arg3 = (int)(SWIG_As_int(obj2));
15392 if (SWIG_arg_fail(3)) SWIG_fail;
15393 }
15394 }
15395 if (obj3) {
15396 {
15397 arg4 = (int)(SWIG_As_int(obj3));
15398 if (SWIG_arg_fail(4)) SWIG_fail;
15399 }
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15404
15405 wxPyEndAllowThreads(__tstate);
15406 if (PyErr_Occurred()) SWIG_fail;
15407 }
15408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15409 return resultobj;
15410 fail:
15411 return NULL;
15412 }
15413
15414
15415 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15416 PyObject *resultobj;
15417 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15418 int result;
15419 PyObject * obj0 = 0 ;
15420 char *kwnames[] = {
15421 (char *) "self", NULL
15422 };
15423
15424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15426 if (SWIG_arg_fail(1)) SWIG_fail;
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15430
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 {
15435 resultobj = SWIG_From_int((int)(result));
15436 }
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15444 PyObject *resultobj;
15445 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15446 int result;
15447 PyObject * obj0 = 0 ;
15448 char *kwnames[] = {
15449 (char *) "self", NULL
15450 };
15451
15452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15454 if (SWIG_arg_fail(1)) SWIG_fail;
15455 {
15456 PyThreadState* __tstate = wxPyBeginAllowThreads();
15457 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15458
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 {
15463 resultobj = SWIG_From_int((int)(result));
15464 }
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj;
15473 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15474 int arg2 ;
15475 PyObject * obj0 = 0 ;
15476 PyObject * obj1 = 0 ;
15477 char *kwnames[] = {
15478 (char *) "self",(char *) "orient", NULL
15479 };
15480
15481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 {
15485 arg2 = (int)(SWIG_As_int(obj1));
15486 if (SWIG_arg_fail(2)) SWIG_fail;
15487 }
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 (arg1)->SetOrientation(arg2);
15491
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 Py_INCREF(Py_None); resultobj = Py_None;
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj;
15504 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15505 int arg2 ;
15506 PyObject * obj0 = 0 ;
15507 PyObject * obj1 = 0 ;
15508 char *kwnames[] = {
15509 (char *) "self",(char *) "pos", NULL
15510 };
15511
15512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(1)) SWIG_fail;
15515 {
15516 arg2 = (int)(SWIG_As_int(obj1));
15517 if (SWIG_arg_fail(2)) SWIG_fail;
15518 }
15519 {
15520 PyThreadState* __tstate = wxPyBeginAllowThreads();
15521 (arg1)->SetPosition(arg2);
15522
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 Py_INCREF(Py_None); resultobj = Py_None;
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15534 PyObject *obj;
15535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15536 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15537 Py_INCREF(obj);
15538 return Py_BuildValue((char *)"");
15539 }
15540 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj;
15542 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15543 int arg2 = (int) 0 ;
15544 int arg3 = (int) 0 ;
15545 wxScrollWinEvent *result;
15546 PyObject * obj0 = 0 ;
15547 PyObject * obj1 = 0 ;
15548 PyObject * obj2 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15554 if (obj0) {
15555 {
15556 arg1 = (wxEventType)(SWIG_As_int(obj0));
15557 if (SWIG_arg_fail(1)) SWIG_fail;
15558 }
15559 }
15560 if (obj1) {
15561 {
15562 arg2 = (int)(SWIG_As_int(obj1));
15563 if (SWIG_arg_fail(2)) SWIG_fail;
15564 }
15565 }
15566 if (obj2) {
15567 {
15568 arg3 = (int)(SWIG_As_int(obj2));
15569 if (SWIG_arg_fail(3)) SWIG_fail;
15570 }
15571 }
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15575
15576 wxPyEndAllowThreads(__tstate);
15577 if (PyErr_Occurred()) SWIG_fail;
15578 }
15579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15580 return resultobj;
15581 fail:
15582 return NULL;
15583 }
15584
15585
15586 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15587 PyObject *resultobj;
15588 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15589 int result;
15590 PyObject * obj0 = 0 ;
15591 char *kwnames[] = {
15592 (char *) "self", NULL
15593 };
15594
15595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15597 if (SWIG_arg_fail(1)) SWIG_fail;
15598 {
15599 PyThreadState* __tstate = wxPyBeginAllowThreads();
15600 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15601
15602 wxPyEndAllowThreads(__tstate);
15603 if (PyErr_Occurred()) SWIG_fail;
15604 }
15605 {
15606 resultobj = SWIG_From_int((int)(result));
15607 }
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15615 PyObject *resultobj;
15616 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15617 int result;
15618 PyObject * obj0 = 0 ;
15619 char *kwnames[] = {
15620 (char *) "self", NULL
15621 };
15622
15623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15625 if (SWIG_arg_fail(1)) SWIG_fail;
15626 {
15627 PyThreadState* __tstate = wxPyBeginAllowThreads();
15628 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15629
15630 wxPyEndAllowThreads(__tstate);
15631 if (PyErr_Occurred()) SWIG_fail;
15632 }
15633 {
15634 resultobj = SWIG_From_int((int)(result));
15635 }
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj;
15644 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15645 int arg2 ;
15646 PyObject * obj0 = 0 ;
15647 PyObject * obj1 = 0 ;
15648 char *kwnames[] = {
15649 (char *) "self",(char *) "orient", NULL
15650 };
15651
15652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15654 if (SWIG_arg_fail(1)) SWIG_fail;
15655 {
15656 arg2 = (int)(SWIG_As_int(obj1));
15657 if (SWIG_arg_fail(2)) SWIG_fail;
15658 }
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 (arg1)->SetOrientation(arg2);
15662
15663 wxPyEndAllowThreads(__tstate);
15664 if (PyErr_Occurred()) SWIG_fail;
15665 }
15666 Py_INCREF(Py_None); resultobj = Py_None;
15667 return resultobj;
15668 fail:
15669 return NULL;
15670 }
15671
15672
15673 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15674 PyObject *resultobj;
15675 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15676 int arg2 ;
15677 PyObject * obj0 = 0 ;
15678 PyObject * obj1 = 0 ;
15679 char *kwnames[] = {
15680 (char *) "self",(char *) "pos", NULL
15681 };
15682
15683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15685 if (SWIG_arg_fail(1)) SWIG_fail;
15686 {
15687 arg2 = (int)(SWIG_As_int(obj1));
15688 if (SWIG_arg_fail(2)) SWIG_fail;
15689 }
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 (arg1)->SetPosition(arg2);
15693
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 Py_INCREF(Py_None); resultobj = Py_None;
15698 return resultobj;
15699 fail:
15700 return NULL;
15701 }
15702
15703
15704 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15705 PyObject *obj;
15706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15707 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15708 Py_INCREF(obj);
15709 return Py_BuildValue((char *)"");
15710 }
15711 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15712 PyObject *resultobj;
15713 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15714 wxMouseEvent *result;
15715 PyObject * obj0 = 0 ;
15716 char *kwnames[] = {
15717 (char *) "mouseType", NULL
15718 };
15719
15720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15721 if (obj0) {
15722 {
15723 arg1 = (wxEventType)(SWIG_As_int(obj0));
15724 if (SWIG_arg_fail(1)) SWIG_fail;
15725 }
15726 }
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15730
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 {
15735 resultobj = wxPyMake_wxObject(result, 1);
15736 }
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15744 PyObject *resultobj;
15745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15746 bool result;
15747 PyObject * obj0 = 0 ;
15748 char *kwnames[] = {
15749 (char *) "self", NULL
15750 };
15751
15752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15754 if (SWIG_arg_fail(1)) SWIG_fail;
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 {
15763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15764 }
15765 return resultobj;
15766 fail:
15767 return NULL;
15768 }
15769
15770
15771 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15772 PyObject *resultobj;
15773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15774 int arg2 = (int) wxMOUSE_BTN_ANY ;
15775 bool result;
15776 PyObject * obj0 = 0 ;
15777 PyObject * obj1 = 0 ;
15778 char *kwnames[] = {
15779 (char *) "self",(char *) "but", NULL
15780 };
15781
15782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15784 if (SWIG_arg_fail(1)) SWIG_fail;
15785 if (obj1) {
15786 {
15787 arg2 = (int)(SWIG_As_int(obj1));
15788 if (SWIG_arg_fail(2)) SWIG_fail;
15789 }
15790 }
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15794
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 {
15799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15800 }
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj;
15809 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15810 int arg2 = (int) wxMOUSE_BTN_ANY ;
15811 bool result;
15812 PyObject * obj0 = 0 ;
15813 PyObject * obj1 = 0 ;
15814 char *kwnames[] = {
15815 (char *) "self",(char *) "but", NULL
15816 };
15817
15818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15820 if (SWIG_arg_fail(1)) SWIG_fail;
15821 if (obj1) {
15822 {
15823 arg2 = (int)(SWIG_As_int(obj1));
15824 if (SWIG_arg_fail(2)) SWIG_fail;
15825 }
15826 }
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15830
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 {
15835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15836 }
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15844 PyObject *resultobj;
15845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15846 int arg2 = (int) wxMOUSE_BTN_ANY ;
15847 bool result;
15848 PyObject * obj0 = 0 ;
15849 PyObject * obj1 = 0 ;
15850 char *kwnames[] = {
15851 (char *) "self",(char *) "but", NULL
15852 };
15853
15854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15856 if (SWIG_arg_fail(1)) SWIG_fail;
15857 if (obj1) {
15858 {
15859 arg2 = (int)(SWIG_As_int(obj1));
15860 if (SWIG_arg_fail(2)) SWIG_fail;
15861 }
15862 }
15863 {
15864 PyThreadState* __tstate = wxPyBeginAllowThreads();
15865 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15866
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 {
15871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15872 }
15873 return resultobj;
15874 fail:
15875 return NULL;
15876 }
15877
15878
15879 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15880 PyObject *resultobj;
15881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15882 int arg2 ;
15883 bool result;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "self",(char *) "but", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15892 if (SWIG_arg_fail(1)) SWIG_fail;
15893 {
15894 arg2 = (int)(SWIG_As_int(obj1));
15895 if (SWIG_arg_fail(2)) SWIG_fail;
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15900
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 {
15905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15906 }
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj;
15915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15916 int arg2 ;
15917 bool result;
15918 PyObject * obj0 = 0 ;
15919 PyObject * obj1 = 0 ;
15920 char *kwnames[] = {
15921 (char *) "self",(char *) "but", NULL
15922 };
15923
15924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15926 if (SWIG_arg_fail(1)) SWIG_fail;
15927 {
15928 arg2 = (int)(SWIG_As_int(obj1));
15929 if (SWIG_arg_fail(2)) SWIG_fail;
15930 }
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15934
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 {
15939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15940 }
15941 return resultobj;
15942 fail:
15943 return NULL;
15944 }
15945
15946
15947 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15948 PyObject *resultobj;
15949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15950 int result;
15951 PyObject * obj0 = 0 ;
15952 char *kwnames[] = {
15953 (char *) "self", NULL
15954 };
15955
15956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15958 if (SWIG_arg_fail(1)) SWIG_fail;
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 {
15967 resultobj = SWIG_From_int((int)(result));
15968 }
15969 return resultobj;
15970 fail:
15971 return NULL;
15972 }
15973
15974
15975 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15976 PyObject *resultobj;
15977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15978 bool result;
15979 PyObject * obj0 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15990
15991 wxPyEndAllowThreads(__tstate);
15992 if (PyErr_Occurred()) SWIG_fail;
15993 }
15994 {
15995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15996 }
15997 return resultobj;
15998 fail:
15999 return NULL;
16000 }
16001
16002
16003 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16004 PyObject *resultobj;
16005 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16006 bool result;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16018
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 {
16023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16024 }
16025 return resultobj;
16026 fail:
16027 return NULL;
16028 }
16029
16030
16031 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj;
16033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16034 bool result;
16035 PyObject * obj0 = 0 ;
16036 char *kwnames[] = {
16037 (char *) "self", NULL
16038 };
16039
16040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16046
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16062 bool result;
16063 PyObject * obj0 = 0 ;
16064 char *kwnames[] = {
16065 (char *) "self", NULL
16066 };
16067
16068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16070 if (SWIG_arg_fail(1)) SWIG_fail;
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16074
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 {
16079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16080 }
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj;
16089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16090 bool result;
16091 PyObject * obj0 = 0 ;
16092 char *kwnames[] = {
16093 (char *) "self", NULL
16094 };
16095
16096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16098 if (SWIG_arg_fail(1)) SWIG_fail;
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16108 }
16109 return resultobj;
16110 fail:
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj;
16117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16118 bool result;
16119 PyObject * obj0 = 0 ;
16120 char *kwnames[] = {
16121 (char *) "self", NULL
16122 };
16123
16124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16126 if (SWIG_arg_fail(1)) SWIG_fail;
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16130
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 {
16135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16136 }
16137 return resultobj;
16138 fail:
16139 return NULL;
16140 }
16141
16142
16143 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16144 PyObject *resultobj;
16145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16146 bool result;
16147 PyObject * obj0 = 0 ;
16148 char *kwnames[] = {
16149 (char *) "self", NULL
16150 };
16151
16152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16154 if (SWIG_arg_fail(1)) SWIG_fail;
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16158
16159 wxPyEndAllowThreads(__tstate);
16160 if (PyErr_Occurred()) SWIG_fail;
16161 }
16162 {
16163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16164 }
16165 return resultobj;
16166 fail:
16167 return NULL;
16168 }
16169
16170
16171 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16172 PyObject *resultobj;
16173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16174 bool result;
16175 PyObject * obj0 = 0 ;
16176 char *kwnames[] = {
16177 (char *) "self", NULL
16178 };
16179
16180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16182 if (SWIG_arg_fail(1)) SWIG_fail;
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16202 bool result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "self", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16210 if (SWIG_arg_fail(1)) SWIG_fail;
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16230 bool result;
16231 PyObject * obj0 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16258 bool result;
16259 PyObject * obj0 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16286 bool result;
16287 PyObject * obj0 = 0 ;
16288 char *kwnames[] = {
16289 (char *) "self", NULL
16290 };
16291
16292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16314 bool result;
16315 PyObject * obj0 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16326
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16342 bool result;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 {
16359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16360 }
16361 return resultobj;
16362 fail:
16363 return NULL;
16364 }
16365
16366
16367 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16370 bool result;
16371 PyObject * obj0 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)(arg1)->LeftIsDown();
16382
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16398 bool result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)(arg1)->MiddleIsDown();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj;
16425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16426 bool result;
16427 PyObject * obj0 = 0 ;
16428 char *kwnames[] = {
16429 (char *) "self", NULL
16430 };
16431
16432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16434 if (SWIG_arg_fail(1)) SWIG_fail;
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 result = (bool)(arg1)->RightIsDown();
16438
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj;
16453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16454 bool result;
16455 PyObject * obj0 = 0 ;
16456 char *kwnames[] = {
16457 (char *) "self", NULL
16458 };
16459
16460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16462 if (SWIG_arg_fail(1)) SWIG_fail;
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 {
16471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16472 }
16473 return resultobj;
16474 fail:
16475 return NULL;
16476 }
16477
16478
16479 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16480 PyObject *resultobj;
16481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16482 bool result;
16483 PyObject * obj0 = 0 ;
16484 char *kwnames[] = {
16485 (char *) "self", NULL
16486 };
16487
16488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16490 if (SWIG_arg_fail(1)) SWIG_fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 {
16499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj;
16509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16510 bool result;
16511 PyObject * obj0 = 0 ;
16512 char *kwnames[] = {
16513 (char *) "self", NULL
16514 };
16515
16516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16518 if (SWIG_arg_fail(1)) SWIG_fail;
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 {
16527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16550
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj;
16565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16566 wxPoint result;
16567 PyObject * obj0 = 0 ;
16568 char *kwnames[] = {
16569 (char *) "self", NULL
16570 };
16571
16572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16574 if (SWIG_arg_fail(1)) SWIG_fail;
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 result = (arg1)->GetPosition();
16578
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 wxPoint * resultptr;
16584 resultptr = new wxPoint((wxPoint &)(result));
16585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16586 }
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj;
16595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16596 long *arg2 = (long *) 0 ;
16597 long *arg3 = (long *) 0 ;
16598 long temp2 ;
16599 int res2 = 0 ;
16600 long temp3 ;
16601 int res3 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 char *kwnames[] = {
16604 (char *) "self", NULL
16605 };
16606
16607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 (arg1)->GetPosition(arg2,arg3);
16615
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 Py_INCREF(Py_None); resultobj = Py_None;
16620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16621 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16623 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16624 return resultobj;
16625 fail:
16626 return NULL;
16627 }
16628
16629
16630 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16631 PyObject *resultobj;
16632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16633 wxDC *arg2 = 0 ;
16634 wxPoint result;
16635 PyObject * obj0 = 0 ;
16636 PyObject * obj1 = 0 ;
16637 char *kwnames[] = {
16638 (char *) "self",(char *) "dc", NULL
16639 };
16640
16641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16643 if (SWIG_arg_fail(1)) SWIG_fail;
16644 {
16645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16646 if (SWIG_arg_fail(2)) SWIG_fail;
16647 if (arg2 == NULL) {
16648 SWIG_null_ref("wxDC");
16649 }
16650 if (SWIG_arg_fail(2)) SWIG_fail;
16651 }
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16655
16656 wxPyEndAllowThreads(__tstate);
16657 if (PyErr_Occurred()) SWIG_fail;
16658 }
16659 {
16660 wxPoint * resultptr;
16661 resultptr = new wxPoint((wxPoint &)(result));
16662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16663 }
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj;
16672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16673 int result;
16674 PyObject * obj0 = 0 ;
16675 char *kwnames[] = {
16676 (char *) "self", NULL
16677 };
16678
16679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16681 if (SWIG_arg_fail(1)) SWIG_fail;
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = (int)((wxMouseEvent const *)arg1)->GetX();
16685
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 {
16690 resultobj = SWIG_From_int((int)(result));
16691 }
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16699 PyObject *resultobj;
16700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16701 int result;
16702 PyObject * obj0 = 0 ;
16703 char *kwnames[] = {
16704 (char *) "self", NULL
16705 };
16706
16707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16709 if (SWIG_arg_fail(1)) SWIG_fail;
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 result = (int)((wxMouseEvent const *)arg1)->GetY();
16713
16714 wxPyEndAllowThreads(__tstate);
16715 if (PyErr_Occurred()) SWIG_fail;
16716 }
16717 {
16718 resultobj = SWIG_From_int((int)(result));
16719 }
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16727 PyObject *resultobj;
16728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16729 int result;
16730 PyObject * obj0 = 0 ;
16731 char *kwnames[] = {
16732 (char *) "self", NULL
16733 };
16734
16735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16737 if (SWIG_arg_fail(1)) SWIG_fail;
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16741
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 {
16746 resultobj = SWIG_From_int((int)(result));
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj;
16756 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16757 int result;
16758 PyObject * obj0 = 0 ;
16759 char *kwnames[] = {
16760 (char *) "self", NULL
16761 };
16762
16763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16765 if (SWIG_arg_fail(1)) SWIG_fail;
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 {
16774 resultobj = SWIG_From_int((int)(result));
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16783 PyObject *resultobj;
16784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16785 int result;
16786 PyObject * obj0 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16797
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 {
16802 resultobj = SWIG_From_int((int)(result));
16803 }
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16811 PyObject *resultobj;
16812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16813 bool result;
16814 PyObject * obj0 = 0 ;
16815 char *kwnames[] = {
16816 (char *) "self", NULL
16817 };
16818
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16825
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 {
16830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16831 }
16832 return resultobj;
16833 fail:
16834 return NULL;
16835 }
16836
16837
16838 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16839 PyObject *resultobj;
16840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16841 int arg2 ;
16842 PyObject * obj0 = 0 ;
16843 PyObject * obj1 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "self",(char *) "m_x", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16850 if (SWIG_arg_fail(1)) SWIG_fail;
16851 {
16852 arg2 = (int)(SWIG_As_int(obj1));
16853 if (SWIG_arg_fail(2)) SWIG_fail;
16854 }
16855 if (arg1) (arg1)->m_x = arg2;
16856
16857 Py_INCREF(Py_None); resultobj = Py_None;
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16867 int result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 result = (int) ((arg1)->m_x);
16877
16878 {
16879 resultobj = SWIG_From_int((int)(result));
16880 }
16881 return resultobj;
16882 fail:
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16890 int arg2 ;
16891 PyObject * obj0 = 0 ;
16892 PyObject * obj1 = 0 ;
16893 char *kwnames[] = {
16894 (char *) "self",(char *) "m_y", NULL
16895 };
16896
16897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16899 if (SWIG_arg_fail(1)) SWIG_fail;
16900 {
16901 arg2 = (int)(SWIG_As_int(obj1));
16902 if (SWIG_arg_fail(2)) SWIG_fail;
16903 }
16904 if (arg1) (arg1)->m_y = arg2;
16905
16906 Py_INCREF(Py_None); resultobj = Py_None;
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16916 int result;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 result = (int) ((arg1)->m_y);
16926
16927 {
16928 resultobj = SWIG_From_int((int)(result));
16929 }
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj;
16938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16939 bool arg2 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char *kwnames[] = {
16943 (char *) "self",(char *) "m_leftDown", NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16948 if (SWIG_arg_fail(1)) SWIG_fail;
16949 {
16950 arg2 = (bool)(SWIG_As_bool(obj1));
16951 if (SWIG_arg_fail(2)) SWIG_fail;
16952 }
16953 if (arg1) (arg1)->m_leftDown = arg2;
16954
16955 Py_INCREF(Py_None); resultobj = Py_None;
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16963 PyObject *resultobj;
16964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16965 bool result;
16966 PyObject * obj0 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 result = (bool) ((arg1)->m_leftDown);
16975
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16986 PyObject *resultobj;
16987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16988 bool arg2 ;
16989 PyObject * obj0 = 0 ;
16990 PyObject * obj1 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self",(char *) "m_middleDown", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 arg2 = (bool)(SWIG_As_bool(obj1));
17000 if (SWIG_arg_fail(2)) SWIG_fail;
17001 }
17002 if (arg1) (arg1)->m_middleDown = arg2;
17003
17004 Py_INCREF(Py_None); resultobj = Py_None;
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17012 PyObject *resultobj;
17013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17014 bool result;
17015 PyObject * obj0 = 0 ;
17016 char *kwnames[] = {
17017 (char *) "self", NULL
17018 };
17019
17020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17022 if (SWIG_arg_fail(1)) SWIG_fail;
17023 result = (bool) ((arg1)->m_middleDown);
17024
17025 {
17026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17027 }
17028 return resultobj;
17029 fail:
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17037 bool arg2 ;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 char *kwnames[] = {
17041 (char *) "self",(char *) "m_rightDown", NULL
17042 };
17043
17044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17046 if (SWIG_arg_fail(1)) SWIG_fail;
17047 {
17048 arg2 = (bool)(SWIG_As_bool(obj1));
17049 if (SWIG_arg_fail(2)) SWIG_fail;
17050 }
17051 if (arg1) (arg1)->m_rightDown = arg2;
17052
17053 Py_INCREF(Py_None); resultobj = Py_None;
17054 return resultobj;
17055 fail:
17056 return NULL;
17057 }
17058
17059
17060 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17061 PyObject *resultobj;
17062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17063 bool result;
17064 PyObject * obj0 = 0 ;
17065 char *kwnames[] = {
17066 (char *) "self", NULL
17067 };
17068
17069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17071 if (SWIG_arg_fail(1)) SWIG_fail;
17072 result = (bool) ((arg1)->m_rightDown);
17073
17074 {
17075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17076 }
17077 return resultobj;
17078 fail:
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj;
17085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17086 bool arg2 ;
17087 PyObject * obj0 = 0 ;
17088 PyObject * obj1 = 0 ;
17089 char *kwnames[] = {
17090 (char *) "self",(char *) "m_controlDown", NULL
17091 };
17092
17093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17095 if (SWIG_arg_fail(1)) SWIG_fail;
17096 {
17097 arg2 = (bool)(SWIG_As_bool(obj1));
17098 if (SWIG_arg_fail(2)) SWIG_fail;
17099 }
17100 if (arg1) (arg1)->m_controlDown = arg2;
17101
17102 Py_INCREF(Py_None); resultobj = Py_None;
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17112 bool result;
17113 PyObject * obj0 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 result = (bool) ((arg1)->m_controlDown);
17122
17123 {
17124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17125 }
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj;
17134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17135 bool arg2 ;
17136 PyObject * obj0 = 0 ;
17137 PyObject * obj1 = 0 ;
17138 char *kwnames[] = {
17139 (char *) "self",(char *) "m_shiftDown", NULL
17140 };
17141
17142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17144 if (SWIG_arg_fail(1)) SWIG_fail;
17145 {
17146 arg2 = (bool)(SWIG_As_bool(obj1));
17147 if (SWIG_arg_fail(2)) SWIG_fail;
17148 }
17149 if (arg1) (arg1)->m_shiftDown = arg2;
17150
17151 Py_INCREF(Py_None); resultobj = Py_None;
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj;
17160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17161 bool result;
17162 PyObject * obj0 = 0 ;
17163 char *kwnames[] = {
17164 (char *) "self", NULL
17165 };
17166
17167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17169 if (SWIG_arg_fail(1)) SWIG_fail;
17170 result = (bool) ((arg1)->m_shiftDown);
17171
17172 {
17173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17174 }
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj;
17183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17184 bool arg2 ;
17185 PyObject * obj0 = 0 ;
17186 PyObject * obj1 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self",(char *) "m_altDown", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 arg2 = (bool)(SWIG_As_bool(obj1));
17196 if (SWIG_arg_fail(2)) SWIG_fail;
17197 }
17198 if (arg1) (arg1)->m_altDown = arg2;
17199
17200 Py_INCREF(Py_None); resultobj = Py_None;
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17208 PyObject *resultobj;
17209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17210 bool result;
17211 PyObject * obj0 = 0 ;
17212 char *kwnames[] = {
17213 (char *) "self", NULL
17214 };
17215
17216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17218 if (SWIG_arg_fail(1)) SWIG_fail;
17219 result = (bool) ((arg1)->m_altDown);
17220
17221 {
17222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17223 }
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17231 PyObject *resultobj;
17232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17233 bool arg2 ;
17234 PyObject * obj0 = 0 ;
17235 PyObject * obj1 = 0 ;
17236 char *kwnames[] = {
17237 (char *) "self",(char *) "m_metaDown", NULL
17238 };
17239
17240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17242 if (SWIG_arg_fail(1)) SWIG_fail;
17243 {
17244 arg2 = (bool)(SWIG_As_bool(obj1));
17245 if (SWIG_arg_fail(2)) SWIG_fail;
17246 }
17247 if (arg1) (arg1)->m_metaDown = arg2;
17248
17249 Py_INCREF(Py_None); resultobj = Py_None;
17250 return resultobj;
17251 fail:
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17259 bool result;
17260 PyObject * obj0 = 0 ;
17261 char *kwnames[] = {
17262 (char *) "self", NULL
17263 };
17264
17265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17267 if (SWIG_arg_fail(1)) SWIG_fail;
17268 result = (bool) ((arg1)->m_metaDown);
17269
17270 {
17271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17272 }
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj;
17281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17282 int arg2 ;
17283 PyObject * obj0 = 0 ;
17284 PyObject * obj1 = 0 ;
17285 char *kwnames[] = {
17286 (char *) "self",(char *) "m_wheelRotation", NULL
17287 };
17288
17289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17291 if (SWIG_arg_fail(1)) SWIG_fail;
17292 {
17293 arg2 = (int)(SWIG_As_int(obj1));
17294 if (SWIG_arg_fail(2)) SWIG_fail;
17295 }
17296 if (arg1) (arg1)->m_wheelRotation = arg2;
17297
17298 Py_INCREF(Py_None); resultobj = Py_None;
17299 return resultobj;
17300 fail:
17301 return NULL;
17302 }
17303
17304
17305 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj;
17307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17308 int result;
17309 PyObject * obj0 = 0 ;
17310 char *kwnames[] = {
17311 (char *) "self", NULL
17312 };
17313
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 result = (int) ((arg1)->m_wheelRotation);
17318
17319 {
17320 resultobj = SWIG_From_int((int)(result));
17321 }
17322 return resultobj;
17323 fail:
17324 return NULL;
17325 }
17326
17327
17328 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17329 PyObject *resultobj;
17330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17331 int arg2 ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 char *kwnames[] = {
17335 (char *) "self",(char *) "m_wheelDelta", NULL
17336 };
17337
17338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17340 if (SWIG_arg_fail(1)) SWIG_fail;
17341 {
17342 arg2 = (int)(SWIG_As_int(obj1));
17343 if (SWIG_arg_fail(2)) SWIG_fail;
17344 }
17345 if (arg1) (arg1)->m_wheelDelta = arg2;
17346
17347 Py_INCREF(Py_None); resultobj = Py_None;
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj;
17356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17357 int result;
17358 PyObject * obj0 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17365 if (SWIG_arg_fail(1)) SWIG_fail;
17366 result = (int) ((arg1)->m_wheelDelta);
17367
17368 {
17369 resultobj = SWIG_From_int((int)(result));
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj;
17379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17380 int arg2 ;
17381 PyObject * obj0 = 0 ;
17382 PyObject * obj1 = 0 ;
17383 char *kwnames[] = {
17384 (char *) "self",(char *) "m_linesPerAction", NULL
17385 };
17386
17387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17389 if (SWIG_arg_fail(1)) SWIG_fail;
17390 {
17391 arg2 = (int)(SWIG_As_int(obj1));
17392 if (SWIG_arg_fail(2)) SWIG_fail;
17393 }
17394 if (arg1) (arg1)->m_linesPerAction = arg2;
17395
17396 Py_INCREF(Py_None); resultobj = Py_None;
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17406 int result;
17407 PyObject * obj0 = 0 ;
17408 char *kwnames[] = {
17409 (char *) "self", NULL
17410 };
17411
17412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17414 if (SWIG_arg_fail(1)) SWIG_fail;
17415 result = (int) ((arg1)->m_linesPerAction);
17416
17417 {
17418 resultobj = SWIG_From_int((int)(result));
17419 }
17420 return resultobj;
17421 fail:
17422 return NULL;
17423 }
17424
17425
17426 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17427 PyObject *obj;
17428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17429 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17430 Py_INCREF(obj);
17431 return Py_BuildValue((char *)"");
17432 }
17433 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj;
17435 int arg1 = (int) 0 ;
17436 int arg2 = (int) 0 ;
17437 wxSetCursorEvent *result;
17438 PyObject * obj0 = 0 ;
17439 PyObject * obj1 = 0 ;
17440 char *kwnames[] = {
17441 (char *) "x",(char *) "y", NULL
17442 };
17443
17444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17445 if (obj0) {
17446 {
17447 arg1 = (int)(SWIG_As_int(obj0));
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 }
17450 }
17451 if (obj1) {
17452 {
17453 arg2 = (int)(SWIG_As_int(obj1));
17454 if (SWIG_arg_fail(2)) SWIG_fail;
17455 }
17456 }
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17460
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17472 PyObject *resultobj;
17473 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17474 int result;
17475 PyObject * obj0 = 0 ;
17476 char *kwnames[] = {
17477 (char *) "self", NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17482 if (SWIG_arg_fail(1)) SWIG_fail;
17483 {
17484 PyThreadState* __tstate = wxPyBeginAllowThreads();
17485 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17486
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 {
17491 resultobj = SWIG_From_int((int)(result));
17492 }
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17502 int result;
17503 PyObject * obj0 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17514
17515 wxPyEndAllowThreads(__tstate);
17516 if (PyErr_Occurred()) SWIG_fail;
17517 }
17518 {
17519 resultobj = SWIG_From_int((int)(result));
17520 }
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17530 wxCursor *arg2 = 0 ;
17531 PyObject * obj0 = 0 ;
17532 PyObject * obj1 = 0 ;
17533 char *kwnames[] = {
17534 (char *) "self",(char *) "cursor", NULL
17535 };
17536
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17542 if (SWIG_arg_fail(2)) SWIG_fail;
17543 if (arg2 == NULL) {
17544 SWIG_null_ref("wxCursor");
17545 }
17546 if (SWIG_arg_fail(2)) SWIG_fail;
17547 }
17548 {
17549 PyThreadState* __tstate = wxPyBeginAllowThreads();
17550 (arg1)->SetCursor((wxCursor const &)*arg2);
17551
17552 wxPyEndAllowThreads(__tstate);
17553 if (PyErr_Occurred()) SWIG_fail;
17554 }
17555 Py_INCREF(Py_None); resultobj = Py_None;
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17565 wxCursor *result;
17566 PyObject * obj0 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 {
17577 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17578 result = (wxCursor *) &_result_ref;
17579 }
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 wxCursor* resultptr = new wxCursor(*result);
17586 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17587 }
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17595 PyObject *resultobj;
17596 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17597 bool result;
17598 PyObject * obj0 = 0 ;
17599 char *kwnames[] = {
17600 (char *) "self", NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17605 if (SWIG_arg_fail(1)) SWIG_fail;
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17609
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17623 PyObject *obj;
17624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17625 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17626 Py_INCREF(obj);
17627 return Py_BuildValue((char *)"");
17628 }
17629 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17630 PyObject *resultobj;
17631 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17632 wxKeyEvent *result;
17633 PyObject * obj0 = 0 ;
17634 char *kwnames[] = {
17635 (char *) "keyType", NULL
17636 };
17637
17638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17639 if (obj0) {
17640 {
17641 arg1 = (wxEventType)(SWIG_As_int(obj0));
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 }
17644 }
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17648
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17653 return resultobj;
17654 fail:
17655 return NULL;
17656 }
17657
17658
17659 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj;
17661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17662 bool result;
17663 PyObject * obj0 = 0 ;
17664 char *kwnames[] = {
17665 (char *) "self", NULL
17666 };
17667
17668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17670 if (SWIG_arg_fail(1)) SWIG_fail;
17671 {
17672 PyThreadState* __tstate = wxPyBeginAllowThreads();
17673 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17674
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17680 }
17681 return resultobj;
17682 fail:
17683 return NULL;
17684 }
17685
17686
17687 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17688 PyObject *resultobj;
17689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17690 bool result;
17691 PyObject * obj0 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 {
17707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17708 }
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17716 PyObject *resultobj;
17717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17718 bool result;
17719 PyObject * obj0 = 0 ;
17720 char *kwnames[] = {
17721 (char *) "self", NULL
17722 };
17723
17724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17726 if (SWIG_arg_fail(1)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 return resultobj;
17738 fail:
17739 return NULL;
17740 }
17741
17742
17743 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17744 PyObject *resultobj;
17745 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17746 bool result;
17747 PyObject * obj0 = 0 ;
17748 char *kwnames[] = {
17749 (char *) "self", NULL
17750 };
17751
17752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17754 if (SWIG_arg_fail(1)) SWIG_fail;
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17758
17759 wxPyEndAllowThreads(__tstate);
17760 if (PyErr_Occurred()) SWIG_fail;
17761 }
17762 {
17763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17764 }
17765 return resultobj;
17766 fail:
17767 return NULL;
17768 }
17769
17770
17771 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17772 PyObject *resultobj;
17773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17774 bool result;
17775 PyObject * obj0 = 0 ;
17776 char *kwnames[] = {
17777 (char *) "self", NULL
17778 };
17779
17780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17782 if (SWIG_arg_fail(1)) SWIG_fail;
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17786
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 {
17791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17792 }
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17802 bool result;
17803 PyObject * obj0 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "self", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 {
17812 PyThreadState* __tstate = wxPyBeginAllowThreads();
17813 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17814
17815 wxPyEndAllowThreads(__tstate);
17816 if (PyErr_Occurred()) SWIG_fail;
17817 }
17818 {
17819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17820 }
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj;
17829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17830 int result;
17831 PyObject * obj0 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "self", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17838 if (SWIG_arg_fail(1)) SWIG_fail;
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17842
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 {
17847 resultobj = SWIG_From_int((int)(result));
17848 }
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj;
17857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17858 int result;
17859 PyObject * obj0 = 0 ;
17860 char *kwnames[] = {
17861 (char *) "self", NULL
17862 };
17863
17864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17866 if (SWIG_arg_fail(1)) SWIG_fail;
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17870
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 {
17875 resultobj = SWIG_From_int((int)(result));
17876 }
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17884 PyObject *resultobj;
17885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17886 unsigned int result;
17887 PyObject * obj0 = 0 ;
17888 char *kwnames[] = {
17889 (char *) "self", NULL
17890 };
17891
17892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 {
17896 PyThreadState* __tstate = wxPyBeginAllowThreads();
17897 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17898
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 {
17903 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17904 }
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17914 unsigned int result;
17915 PyObject * obj0 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17926
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj;
17941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17942 wxPoint result;
17943 PyObject * obj0 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (arg1)->GetPosition();
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 wxPoint * resultptr;
17960 resultptr = new wxPoint((wxPoint &)(result));
17961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17972 long *arg2 = (long *) 0 ;
17973 long *arg3 = (long *) 0 ;
17974 long temp2 ;
17975 int res2 = 0 ;
17976 long temp3 ;
17977 int res3 = 0 ;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17984 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17987 if (SWIG_arg_fail(1)) SWIG_fail;
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 (arg1)->GetPosition(arg2,arg3);
17991
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 Py_INCREF(Py_None); resultobj = Py_None;
17996 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17997 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17998 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17999 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18007 PyObject *resultobj;
18008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18009 int result;
18010 PyObject * obj0 = 0 ;
18011 char *kwnames[] = {
18012 (char *) "self", NULL
18013 };
18014
18015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18017 if (SWIG_arg_fail(1)) SWIG_fail;
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (int)((wxKeyEvent const *)arg1)->GetX();
18021
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 {
18026 resultobj = SWIG_From_int((int)(result));
18027 }
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18035 PyObject *resultobj;
18036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18037 int result;
18038 PyObject * obj0 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (int)((wxKeyEvent const *)arg1)->GetY();
18049
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 {
18054 resultobj = SWIG_From_int((int)(result));
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18065 int arg2 ;
18066 PyObject * obj0 = 0 ;
18067 PyObject * obj1 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self",(char *) "m_x", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 arg2 = (int)(SWIG_As_int(obj1));
18077 if (SWIG_arg_fail(2)) SWIG_fail;
18078 }
18079 if (arg1) (arg1)->m_x = arg2;
18080
18081 Py_INCREF(Py_None); resultobj = Py_None;
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18089 PyObject *resultobj;
18090 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18091 int result;
18092 PyObject * obj0 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 result = (int) ((arg1)->m_x);
18101
18102 {
18103 resultobj = SWIG_From_int((int)(result));
18104 }
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18112 PyObject *resultobj;
18113 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18114 int arg2 ;
18115 PyObject * obj0 = 0 ;
18116 PyObject * obj1 = 0 ;
18117 char *kwnames[] = {
18118 (char *) "self",(char *) "m_y", NULL
18119 };
18120
18121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18123 if (SWIG_arg_fail(1)) SWIG_fail;
18124 {
18125 arg2 = (int)(SWIG_As_int(obj1));
18126 if (SWIG_arg_fail(2)) SWIG_fail;
18127 }
18128 if (arg1) (arg1)->m_y = arg2;
18129
18130 Py_INCREF(Py_None); resultobj = Py_None;
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj;
18139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18140 int result;
18141 PyObject * obj0 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 result = (int) ((arg1)->m_y);
18150
18151 {
18152 resultobj = SWIG_From_int((int)(result));
18153 }
18154 return resultobj;
18155 fail:
18156 return NULL;
18157 }
18158
18159
18160 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18161 PyObject *resultobj;
18162 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18163 long arg2 ;
18164 PyObject * obj0 = 0 ;
18165 PyObject * obj1 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self",(char *) "m_keyCode", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 arg2 = (long)(SWIG_As_long(obj1));
18175 if (SWIG_arg_fail(2)) SWIG_fail;
18176 }
18177 if (arg1) (arg1)->m_keyCode = arg2;
18178
18179 Py_INCREF(Py_None); resultobj = Py_None;
18180 return resultobj;
18181 fail:
18182 return NULL;
18183 }
18184
18185
18186 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18189 long result;
18190 PyObject * obj0 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 result = (long) ((arg1)->m_keyCode);
18199
18200 {
18201 resultobj = SWIG_From_long((long)(result));
18202 }
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18210 PyObject *resultobj;
18211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18212 bool arg2 ;
18213 PyObject * obj0 = 0 ;
18214 PyObject * obj1 = 0 ;
18215 char *kwnames[] = {
18216 (char *) "self",(char *) "m_controlDown", NULL
18217 };
18218
18219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18221 if (SWIG_arg_fail(1)) SWIG_fail;
18222 {
18223 arg2 = (bool)(SWIG_As_bool(obj1));
18224 if (SWIG_arg_fail(2)) SWIG_fail;
18225 }
18226 if (arg1) (arg1)->m_controlDown = arg2;
18227
18228 Py_INCREF(Py_None); resultobj = Py_None;
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj;
18237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18238 bool result;
18239 PyObject * obj0 = 0 ;
18240 char *kwnames[] = {
18241 (char *) "self", NULL
18242 };
18243
18244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18246 if (SWIG_arg_fail(1)) SWIG_fail;
18247 result = (bool) ((arg1)->m_controlDown);
18248
18249 {
18250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18261 bool arg2 ;
18262 PyObject * obj0 = 0 ;
18263 PyObject * obj1 = 0 ;
18264 char *kwnames[] = {
18265 (char *) "self",(char *) "m_shiftDown", NULL
18266 };
18267
18268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18270 if (SWIG_arg_fail(1)) SWIG_fail;
18271 {
18272 arg2 = (bool)(SWIG_As_bool(obj1));
18273 if (SWIG_arg_fail(2)) SWIG_fail;
18274 }
18275 if (arg1) (arg1)->m_shiftDown = arg2;
18276
18277 Py_INCREF(Py_None); resultobj = Py_None;
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18287 bool result;
18288 PyObject * obj0 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 result = (bool) ((arg1)->m_shiftDown);
18297
18298 {
18299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj;
18309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18310 bool arg2 ;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 char *kwnames[] = {
18314 (char *) "self",(char *) "m_altDown", NULL
18315 };
18316
18317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18319 if (SWIG_arg_fail(1)) SWIG_fail;
18320 {
18321 arg2 = (bool)(SWIG_As_bool(obj1));
18322 if (SWIG_arg_fail(2)) SWIG_fail;
18323 }
18324 if (arg1) (arg1)->m_altDown = arg2;
18325
18326 Py_INCREF(Py_None); resultobj = Py_None;
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18334 PyObject *resultobj;
18335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18336 bool result;
18337 PyObject * obj0 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "self", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 result = (bool) ((arg1)->m_altDown);
18346
18347 {
18348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18349 }
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj;
18358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18359 bool arg2 ;
18360 PyObject * obj0 = 0 ;
18361 PyObject * obj1 = 0 ;
18362 char *kwnames[] = {
18363 (char *) "self",(char *) "m_metaDown", NULL
18364 };
18365
18366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18368 if (SWIG_arg_fail(1)) SWIG_fail;
18369 {
18370 arg2 = (bool)(SWIG_As_bool(obj1));
18371 if (SWIG_arg_fail(2)) SWIG_fail;
18372 }
18373 if (arg1) (arg1)->m_metaDown = arg2;
18374
18375 Py_INCREF(Py_None); resultobj = Py_None;
18376 return resultobj;
18377 fail:
18378 return NULL;
18379 }
18380
18381
18382 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18383 PyObject *resultobj;
18384 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18385 bool result;
18386 PyObject * obj0 = 0 ;
18387 char *kwnames[] = {
18388 (char *) "self", NULL
18389 };
18390
18391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18393 if (SWIG_arg_fail(1)) SWIG_fail;
18394 result = (bool) ((arg1)->m_metaDown);
18395
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18408 bool arg2 ;
18409 PyObject * obj0 = 0 ;
18410 PyObject * obj1 = 0 ;
18411 char *kwnames[] = {
18412 (char *) "self",(char *) "m_scanCode", NULL
18413 };
18414
18415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18417 if (SWIG_arg_fail(1)) SWIG_fail;
18418 {
18419 arg2 = (bool)(SWIG_As_bool(obj1));
18420 if (SWIG_arg_fail(2)) SWIG_fail;
18421 }
18422 if (arg1) (arg1)->m_scanCode = arg2;
18423
18424 Py_INCREF(Py_None); resultobj = Py_None;
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18432 PyObject *resultobj;
18433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18434 bool result;
18435 PyObject * obj0 = 0 ;
18436 char *kwnames[] = {
18437 (char *) "self", NULL
18438 };
18439
18440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18442 if (SWIG_arg_fail(1)) SWIG_fail;
18443 result = (bool) ((arg1)->m_scanCode);
18444
18445 {
18446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18447 }
18448 return resultobj;
18449 fail:
18450 return NULL;
18451 }
18452
18453
18454 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18455 PyObject *resultobj;
18456 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18457 unsigned int arg2 ;
18458 PyObject * obj0 = 0 ;
18459 PyObject * obj1 = 0 ;
18460 char *kwnames[] = {
18461 (char *) "self",(char *) "m_rawCode", NULL
18462 };
18463
18464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18466 if (SWIG_arg_fail(1)) SWIG_fail;
18467 {
18468 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18469 if (SWIG_arg_fail(2)) SWIG_fail;
18470 }
18471 if (arg1) (arg1)->m_rawCode = arg2;
18472
18473 Py_INCREF(Py_None); resultobj = Py_None;
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18483 unsigned int result;
18484 PyObject * obj0 = 0 ;
18485 char *kwnames[] = {
18486 (char *) "self", NULL
18487 };
18488
18489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18491 if (SWIG_arg_fail(1)) SWIG_fail;
18492 result = (unsigned int) ((arg1)->m_rawCode);
18493
18494 {
18495 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18496 }
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18504 PyObject *resultobj;
18505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18506 unsigned int arg2 ;
18507 PyObject * obj0 = 0 ;
18508 PyObject * obj1 = 0 ;
18509 char *kwnames[] = {
18510 (char *) "self",(char *) "m_rawFlags", NULL
18511 };
18512
18513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18515 if (SWIG_arg_fail(1)) SWIG_fail;
18516 {
18517 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18518 if (SWIG_arg_fail(2)) SWIG_fail;
18519 }
18520 if (arg1) (arg1)->m_rawFlags = arg2;
18521
18522 Py_INCREF(Py_None); resultobj = Py_None;
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18530 PyObject *resultobj;
18531 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18532 unsigned int result;
18533 PyObject * obj0 = 0 ;
18534 char *kwnames[] = {
18535 (char *) "self", NULL
18536 };
18537
18538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18540 if (SWIG_arg_fail(1)) SWIG_fail;
18541 result = (unsigned int) ((arg1)->m_rawFlags);
18542
18543 {
18544 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18545 }
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18553 PyObject *obj;
18554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18555 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18556 Py_INCREF(obj);
18557 return Py_BuildValue((char *)"");
18558 }
18559 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxSize const &arg1_defvalue = wxDefaultSize ;
18562 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18563 int arg2 = (int) 0 ;
18564 wxSizeEvent *result;
18565 wxSize temp1 ;
18566 PyObject * obj0 = 0 ;
18567 PyObject * obj1 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "sz",(char *) "winid", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18573 if (obj0) {
18574 {
18575 arg1 = &temp1;
18576 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18577 }
18578 }
18579 if (obj1) {
18580 {
18581 arg2 = (int)(SWIG_As_int(obj1));
18582 if (SWIG_arg_fail(2)) SWIG_fail;
18583 }
18584 }
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj;
18601 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18602 wxSize result;
18603 PyObject * obj0 = 0 ;
18604 char *kwnames[] = {
18605 (char *) "self", NULL
18606 };
18607
18608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18610 if (SWIG_arg_fail(1)) SWIG_fail;
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = ((wxSizeEvent const *)arg1)->GetSize();
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 wxSize * resultptr;
18620 resultptr = new wxSize((wxSize &)(result));
18621 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18632 wxRect result;
18633 PyObject * obj0 = 0 ;
18634 char *kwnames[] = {
18635 (char *) "self", NULL
18636 };
18637
18638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18640 if (SWIG_arg_fail(1)) SWIG_fail;
18641 {
18642 PyThreadState* __tstate = wxPyBeginAllowThreads();
18643 result = ((wxSizeEvent const *)arg1)->GetRect();
18644
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 {
18649 wxRect * resultptr;
18650 resultptr = new wxRect((wxRect &)(result));
18651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18652 }
18653 return resultobj;
18654 fail:
18655 return NULL;
18656 }
18657
18658
18659 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18660 PyObject *resultobj;
18661 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18662 wxRect arg2 ;
18663 PyObject * obj0 = 0 ;
18664 PyObject * obj1 = 0 ;
18665 char *kwnames[] = {
18666 (char *) "self",(char *) "rect", NULL
18667 };
18668
18669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18671 if (SWIG_arg_fail(1)) SWIG_fail;
18672 {
18673 wxRect * argp;
18674 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18675 if (SWIG_arg_fail(2)) SWIG_fail;
18676 if (argp == NULL) {
18677 SWIG_null_ref("wxRect");
18678 }
18679 if (SWIG_arg_fail(2)) SWIG_fail;
18680 arg2 = *argp;
18681 }
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 (arg1)->SetRect(arg2);
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 Py_INCREF(Py_None); resultobj = Py_None;
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18699 wxSize arg2 ;
18700 PyObject * obj0 = 0 ;
18701 PyObject * obj1 = 0 ;
18702 char *kwnames[] = {
18703 (char *) "self",(char *) "size", NULL
18704 };
18705
18706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18708 if (SWIG_arg_fail(1)) SWIG_fail;
18709 {
18710 wxSize * argp;
18711 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 if (argp == NULL) {
18714 SWIG_null_ref("wxSize");
18715 }
18716 if (SWIG_arg_fail(2)) SWIG_fail;
18717 arg2 = *argp;
18718 }
18719 {
18720 PyThreadState* __tstate = wxPyBeginAllowThreads();
18721 wxSizeEvent_SetSize(arg1,arg2);
18722
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 Py_INCREF(Py_None); resultobj = Py_None;
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18734 PyObject *resultobj;
18735 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18736 wxSize *arg2 = (wxSize *) 0 ;
18737 PyObject * obj0 = 0 ;
18738 PyObject * obj1 = 0 ;
18739 char *kwnames[] = {
18740 (char *) "self",(char *) "m_size", NULL
18741 };
18742
18743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(2)) SWIG_fail;
18748 if (arg1) (arg1)->m_size = *arg2;
18749
18750 Py_INCREF(Py_None); resultobj = Py_None;
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj;
18759 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18760 wxSize *result;
18761 PyObject * obj0 = 0 ;
18762 char *kwnames[] = {
18763 (char *) "self", NULL
18764 };
18765
18766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18768 if (SWIG_arg_fail(1)) SWIG_fail;
18769 result = (wxSize *)& ((arg1)->m_size);
18770
18771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18781 wxRect *arg2 = (wxRect *) 0 ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self",(char *) "m_rect", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(2)) SWIG_fail;
18793 if (arg1) (arg1)->m_rect = *arg2;
18794
18795 Py_INCREF(Py_None); resultobj = Py_None;
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18805 wxRect *result;
18806 PyObject * obj0 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 result = (wxRect *)& ((arg1)->m_rect);
18815
18816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18824 PyObject *obj;
18825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18826 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18827 Py_INCREF(obj);
18828 return Py_BuildValue((char *)"");
18829 }
18830 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18831 PyObject *resultobj;
18832 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18833 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18834 int arg2 = (int) 0 ;
18835 wxMoveEvent *result;
18836 wxPoint temp1 ;
18837 PyObject * obj0 = 0 ;
18838 PyObject * obj1 = 0 ;
18839 char *kwnames[] = {
18840 (char *) "pos",(char *) "winid", NULL
18841 };
18842
18843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18844 if (obj0) {
18845 {
18846 arg1 = &temp1;
18847 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18848 }
18849 }
18850 if (obj1) {
18851 {
18852 arg2 = (int)(SWIG_As_int(obj1));
18853 if (SWIG_arg_fail(2)) SWIG_fail;
18854 }
18855 }
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18859
18860 wxPyEndAllowThreads(__tstate);
18861 if (PyErr_Occurred()) SWIG_fail;
18862 }
18863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj;
18872 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18873 wxPoint result;
18874 PyObject * obj0 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 result = ((wxMoveEvent const *)arg1)->GetPosition();
18885
18886 wxPyEndAllowThreads(__tstate);
18887 if (PyErr_Occurred()) SWIG_fail;
18888 }
18889 {
18890 wxPoint * resultptr;
18891 resultptr = new wxPoint((wxPoint &)(result));
18892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18893 }
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj;
18902 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18903 wxRect result;
18904 PyObject * obj0 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "self", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18911 if (SWIG_arg_fail(1)) SWIG_fail;
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 result = ((wxMoveEvent const *)arg1)->GetRect();
18915
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 {
18920 wxRect * resultptr;
18921 resultptr = new wxRect((wxRect &)(result));
18922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18923 }
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18931 PyObject *resultobj;
18932 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18933 wxRect arg2 ;
18934 PyObject * obj0 = 0 ;
18935 PyObject * obj1 = 0 ;
18936 char *kwnames[] = {
18937 (char *) "self",(char *) "rect", NULL
18938 };
18939
18940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18942 if (SWIG_arg_fail(1)) SWIG_fail;
18943 {
18944 wxRect * argp;
18945 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18946 if (SWIG_arg_fail(2)) SWIG_fail;
18947 if (argp == NULL) {
18948 SWIG_null_ref("wxRect");
18949 }
18950 if (SWIG_arg_fail(2)) SWIG_fail;
18951 arg2 = *argp;
18952 }
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 (arg1)->SetRect(arg2);
18956
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 Py_INCREF(Py_None); resultobj = Py_None;
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj;
18969 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18970 wxPoint arg2 ;
18971 PyObject * obj0 = 0 ;
18972 PyObject * obj1 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "self",(char *) "pos", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(1)) SWIG_fail;
18980 {
18981 wxPoint * argp;
18982 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
18983 if (SWIG_arg_fail(2)) SWIG_fail;
18984 if (argp == NULL) {
18985 SWIG_null_ref("wxPoint");
18986 }
18987 if (SWIG_arg_fail(2)) SWIG_fail;
18988 arg2 = *argp;
18989 }
18990 {
18991 PyThreadState* __tstate = wxPyBeginAllowThreads();
18992 wxMoveEvent_SetPosition(arg1,arg2);
18993
18994 wxPyEndAllowThreads(__tstate);
18995 if (PyErr_Occurred()) SWIG_fail;
18996 }
18997 Py_INCREF(Py_None); resultobj = Py_None;
18998 return resultobj;
18999 fail:
19000 return NULL;
19001 }
19002
19003
19004 static PyObject *_wrap_MoveEvent_m_pos_set(PyObject *, PyObject *args, PyObject *kwargs) {
19005 PyObject *resultobj;
19006 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19007 wxPoint *arg2 = (wxPoint *) 0 ;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char *kwnames[] = {
19011 (char *) "self",(char *) "m_pos", NULL
19012 };
19013
19014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_pos_set",kwnames,&obj0,&obj1)) goto fail;
19015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19016 if (SWIG_arg_fail(1)) SWIG_fail;
19017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
19018 if (SWIG_arg_fail(2)) SWIG_fail;
19019 if (arg1) (arg1)->m_pos = *arg2;
19020
19021 Py_INCREF(Py_None); resultobj = Py_None;
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 static PyObject *_wrap_MoveEvent_m_pos_get(PyObject *, PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj;
19030 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19031 wxPoint *result;
19032 PyObject * obj0 = 0 ;
19033 char *kwnames[] = {
19034 (char *) "self", NULL
19035 };
19036
19037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_pos_get",kwnames,&obj0)) goto fail;
19038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19039 if (SWIG_arg_fail(1)) SWIG_fail;
19040 result = (wxPoint *)& ((arg1)->m_pos);
19041
19042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
19043 return resultobj;
19044 fail:
19045 return NULL;
19046 }
19047
19048
19049 static PyObject *_wrap_MoveEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj;
19051 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19052 wxRect *arg2 = (wxRect *) 0 ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self",(char *) "m_rect", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19063 if (SWIG_arg_fail(2)) SWIG_fail;
19064 if (arg1) (arg1)->m_rect = *arg2;
19065
19066 Py_INCREF(Py_None); resultobj = Py_None;
19067 return resultobj;
19068 fail:
19069 return NULL;
19070 }
19071
19072
19073 static PyObject *_wrap_MoveEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19074 PyObject *resultobj;
19075 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19076 wxRect *result;
19077 PyObject * obj0 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "self", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_m_rect_get",kwnames,&obj0)) goto fail;
19083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19084 if (SWIG_arg_fail(1)) SWIG_fail;
19085 result = (wxRect *)& ((arg1)->m_rect);
19086
19087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19095 PyObject *obj;
19096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19097 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19098 Py_INCREF(obj);
19099 return Py_BuildValue((char *)"");
19100 }
19101 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 int arg1 = (int) 0 ;
19104 wxPaintEvent *result;
19105 PyObject * obj0 = 0 ;
19106 char *kwnames[] = {
19107 (char *) "Id", NULL
19108 };
19109
19110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19111 if (obj0) {
19112 {
19113 arg1 = (int)(SWIG_As_int(obj0));
19114 if (SWIG_arg_fail(1)) SWIG_fail;
19115 }
19116 }
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19120
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19132 PyObject *obj;
19133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19134 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19135 Py_INCREF(obj);
19136 return Py_BuildValue((char *)"");
19137 }
19138 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19139 PyObject *resultobj;
19140 int arg1 = (int) 0 ;
19141 wxNcPaintEvent *result;
19142 PyObject * obj0 = 0 ;
19143 char *kwnames[] = {
19144 (char *) "winid", NULL
19145 };
19146
19147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19148 if (obj0) {
19149 {
19150 arg1 = (int)(SWIG_As_int(obj0));
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 }
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19169 PyObject *obj;
19170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19171 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19172 Py_INCREF(obj);
19173 return Py_BuildValue((char *)"");
19174 }
19175 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19176 PyObject *resultobj;
19177 int arg1 = (int) 0 ;
19178 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19179 wxEraseEvent *result;
19180 PyObject * obj0 = 0 ;
19181 PyObject * obj1 = 0 ;
19182 char *kwnames[] = {
19183 (char *) "Id",(char *) "dc", NULL
19184 };
19185
19186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19187 if (obj0) {
19188 {
19189 arg1 = (int)(SWIG_As_int(obj0));
19190 if (SWIG_arg_fail(1)) SWIG_fail;
19191 }
19192 }
19193 if (obj1) {
19194 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(2)) SWIG_fail;
19196 }
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19200
19201 wxPyEndAllowThreads(__tstate);
19202 if (PyErr_Occurred()) SWIG_fail;
19203 }
19204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj;
19213 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19214 wxDC *result;
19215 PyObject * obj0 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "self", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19226
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 {
19231 resultobj = wxPyMake_wxObject(result, 0);
19232 }
19233 return resultobj;
19234 fail:
19235 return NULL;
19236 }
19237
19238
19239 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19240 PyObject *obj;
19241 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19242 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19243 Py_INCREF(obj);
19244 return Py_BuildValue((char *)"");
19245 }
19246 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19249 int arg2 = (int) 0 ;
19250 wxFocusEvent *result;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "type",(char *) "winid", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19258 if (obj0) {
19259 {
19260 arg1 = (wxEventType)(SWIG_As_int(obj0));
19261 if (SWIG_arg_fail(1)) SWIG_fail;
19262 }
19263 }
19264 if (obj1) {
19265 {
19266 arg2 = (int)(SWIG_As_int(obj1));
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19287 wxWindow *result;
19288 PyObject * obj0 = 0 ;
19289 char *kwnames[] = {
19290 (char *) "self", NULL
19291 };
19292
19293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19299
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 {
19304 resultobj = wxPyMake_wxObject(result, 0);
19305 }
19306 return resultobj;
19307 fail:
19308 return NULL;
19309 }
19310
19311
19312 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19313 PyObject *resultobj;
19314 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19315 wxWindow *arg2 = (wxWindow *) 0 ;
19316 PyObject * obj0 = 0 ;
19317 PyObject * obj1 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "self",(char *) "win", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(1)) SWIG_fail;
19325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19326 if (SWIG_arg_fail(2)) SWIG_fail;
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 (arg1)->SetWindow(arg2);
19330
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 Py_INCREF(Py_None); resultobj = Py_None;
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19342 PyObject *obj;
19343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19344 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19345 Py_INCREF(obj);
19346 return Py_BuildValue((char *)"");
19347 }
19348 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj;
19350 wxWindow *arg1 = (wxWindow *) NULL ;
19351 wxChildFocusEvent *result;
19352 PyObject * obj0 = 0 ;
19353 char *kwnames[] = {
19354 (char *) "win", NULL
19355 };
19356
19357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19358 if (obj0) {
19359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19360 if (SWIG_arg_fail(1)) SWIG_fail;
19361 }
19362 {
19363 PyThreadState* __tstate = wxPyBeginAllowThreads();
19364 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19365
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj;
19378 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19379 wxWindow *result;
19380 PyObject * obj0 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "self", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19387 if (SWIG_arg_fail(1)) SWIG_fail;
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 {
19396 resultobj = wxPyMake_wxObject(result, 0);
19397 }
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19405 PyObject *obj;
19406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19407 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19408 Py_INCREF(obj);
19409 return Py_BuildValue((char *)"");
19410 }
19411 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19412 PyObject *resultobj;
19413 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19414 bool arg2 = (bool) true ;
19415 int arg3 = (int) 0 ;
19416 wxActivateEvent *result;
19417 PyObject * obj0 = 0 ;
19418 PyObject * obj1 = 0 ;
19419 PyObject * obj2 = 0 ;
19420 char *kwnames[] = {
19421 (char *) "type",(char *) "active",(char *) "Id", NULL
19422 };
19423
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19425 if (obj0) {
19426 {
19427 arg1 = (wxEventType)(SWIG_As_int(obj0));
19428 if (SWIG_arg_fail(1)) SWIG_fail;
19429 }
19430 }
19431 if (obj1) {
19432 {
19433 arg2 = (bool)(SWIG_As_bool(obj1));
19434 if (SWIG_arg_fail(2)) SWIG_fail;
19435 }
19436 }
19437 if (obj2) {
19438 {
19439 arg3 = (int)(SWIG_As_int(obj2));
19440 if (SWIG_arg_fail(3)) SWIG_fail;
19441 }
19442 }
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19460 bool result;
19461 PyObject * obj0 = 0 ;
19462 char *kwnames[] = {
19463 (char *) "self", NULL
19464 };
19465
19466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19468 if (SWIG_arg_fail(1)) SWIG_fail;
19469 {
19470 PyThreadState* __tstate = wxPyBeginAllowThreads();
19471 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19472
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 {
19477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19478 }
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19486 PyObject *obj;
19487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19488 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19489 Py_INCREF(obj);
19490 return Py_BuildValue((char *)"");
19491 }
19492 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 int arg1 = (int) 0 ;
19495 wxInitDialogEvent *result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "Id", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19502 if (obj0) {
19503 {
19504 arg1 = (int)(SWIG_As_int(obj0));
19505 if (SWIG_arg_fail(1)) SWIG_fail;
19506 }
19507 }
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19516 return resultobj;
19517 fail:
19518 return NULL;
19519 }
19520
19521
19522 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19523 PyObject *obj;
19524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19525 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19526 Py_INCREF(obj);
19527 return Py_BuildValue((char *)"");
19528 }
19529 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19532 int arg2 = (int) 0 ;
19533 wxMenu *arg3 = (wxMenu *) NULL ;
19534 wxMenuEvent *result;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 PyObject * obj2 = 0 ;
19538 char *kwnames[] = {
19539 (char *) "type",(char *) "winid",(char *) "menu", NULL
19540 };
19541
19542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19543 if (obj0) {
19544 {
19545 arg1 = (wxEventType)(SWIG_As_int(obj0));
19546 if (SWIG_arg_fail(1)) SWIG_fail;
19547 }
19548 }
19549 if (obj1) {
19550 {
19551 arg2 = (int)(SWIG_As_int(obj1));
19552 if (SWIG_arg_fail(2)) SWIG_fail;
19553 }
19554 }
19555 if (obj2) {
19556 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19557 if (SWIG_arg_fail(3)) SWIG_fail;
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19576 int result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 resultobj = SWIG_From_int((int)(result));
19594 }
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19602 PyObject *resultobj;
19603 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19604 bool result;
19605 PyObject * obj0 = 0 ;
19606 char *kwnames[] = {
19607 (char *) "self", NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19616
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 {
19621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19622 }
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19630 PyObject *resultobj;
19631 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19632 wxMenu *result;
19633 PyObject * obj0 = 0 ;
19634 char *kwnames[] = {
19635 (char *) "self", NULL
19636 };
19637
19638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19640 if (SWIG_arg_fail(1)) SWIG_fail;
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19644
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 {
19649 resultobj = wxPyMake_wxObject(result, 0);
19650 }
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19658 PyObject *obj;
19659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19660 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19661 Py_INCREF(obj);
19662 return Py_BuildValue((char *)"");
19663 }
19664 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj;
19666 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19667 int arg2 = (int) 0 ;
19668 wxCloseEvent *result;
19669 PyObject * obj0 = 0 ;
19670 PyObject * obj1 = 0 ;
19671 char *kwnames[] = {
19672 (char *) "type",(char *) "winid", NULL
19673 };
19674
19675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19676 if (obj0) {
19677 {
19678 arg1 = (wxEventType)(SWIG_As_int(obj0));
19679 if (SWIG_arg_fail(1)) SWIG_fail;
19680 }
19681 }
19682 if (obj1) {
19683 {
19684 arg2 = (int)(SWIG_As_int(obj1));
19685 if (SWIG_arg_fail(2)) SWIG_fail;
19686 }
19687 }
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19691
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj;
19704 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19705 bool arg2 ;
19706 PyObject * obj0 = 0 ;
19707 PyObject * obj1 = 0 ;
19708 char *kwnames[] = {
19709 (char *) "self",(char *) "logOff", NULL
19710 };
19711
19712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19714 if (SWIG_arg_fail(1)) SWIG_fail;
19715 {
19716 arg2 = (bool)(SWIG_As_bool(obj1));
19717 if (SWIG_arg_fail(2)) SWIG_fail;
19718 }
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 (arg1)->SetLoggingOff(arg2);
19722
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 Py_INCREF(Py_None); resultobj = Py_None;
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19734 PyObject *resultobj;
19735 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19736 bool result;
19737 PyObject * obj0 = 0 ;
19738 char *kwnames[] = {
19739 (char *) "self", NULL
19740 };
19741
19742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19744 if (SWIG_arg_fail(1)) SWIG_fail;
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19748
19749 wxPyEndAllowThreads(__tstate);
19750 if (PyErr_Occurred()) SWIG_fail;
19751 }
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19764 bool arg2 = (bool) true ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char *kwnames[] = {
19768 (char *) "self",(char *) "veto", NULL
19769 };
19770
19771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 if (obj1) {
19775 {
19776 arg2 = (bool)(SWIG_As_bool(obj1));
19777 if (SWIG_arg_fail(2)) SWIG_fail;
19778 }
19779 }
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 (arg1)->Veto(arg2);
19783
19784 wxPyEndAllowThreads(__tstate);
19785 if (PyErr_Occurred()) SWIG_fail;
19786 }
19787 Py_INCREF(Py_None); resultobj = Py_None;
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19795 PyObject *resultobj;
19796 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19797 bool arg2 ;
19798 PyObject * obj0 = 0 ;
19799 PyObject * obj1 = 0 ;
19800 char *kwnames[] = {
19801 (char *) "self",(char *) "canVeto", NULL
19802 };
19803
19804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19806 if (SWIG_arg_fail(1)) SWIG_fail;
19807 {
19808 arg2 = (bool)(SWIG_As_bool(obj1));
19809 if (SWIG_arg_fail(2)) SWIG_fail;
19810 }
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 (arg1)->SetCanVeto(arg2);
19814
19815 wxPyEndAllowThreads(__tstate);
19816 if (PyErr_Occurred()) SWIG_fail;
19817 }
19818 Py_INCREF(Py_None); resultobj = Py_None;
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj;
19827 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19828 bool result;
19829 PyObject * obj0 = 0 ;
19830 char *kwnames[] = {
19831 (char *) "self", NULL
19832 };
19833
19834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19836 if (SWIG_arg_fail(1)) SWIG_fail;
19837 {
19838 PyThreadState* __tstate = wxPyBeginAllowThreads();
19839 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19840
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 {
19845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19846 }
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19854 PyObject *resultobj;
19855 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19856 bool result;
19857 PyObject * obj0 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "self", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 {
19873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19882 PyObject *obj;
19883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19884 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19885 Py_INCREF(obj);
19886 return Py_BuildValue((char *)"");
19887 }
19888 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj;
19890 int arg1 = (int) 0 ;
19891 bool arg2 = (bool) false ;
19892 wxShowEvent *result;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 char *kwnames[] = {
19896 (char *) "winid",(char *) "show", NULL
19897 };
19898
19899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19900 if (obj0) {
19901 {
19902 arg1 = (int)(SWIG_As_int(obj0));
19903 if (SWIG_arg_fail(1)) SWIG_fail;
19904 }
19905 }
19906 if (obj1) {
19907 {
19908 arg2 = (bool)(SWIG_As_bool(obj1));
19909 if (SWIG_arg_fail(2)) SWIG_fail;
19910 }
19911 }
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj;
19928 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19929 bool arg2 ;
19930 PyObject * obj0 = 0 ;
19931 PyObject * obj1 = 0 ;
19932 char *kwnames[] = {
19933 (char *) "self",(char *) "show", NULL
19934 };
19935
19936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19938 if (SWIG_arg_fail(1)) SWIG_fail;
19939 {
19940 arg2 = (bool)(SWIG_As_bool(obj1));
19941 if (SWIG_arg_fail(2)) SWIG_fail;
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 (arg1)->SetShow(arg2);
19946
19947 wxPyEndAllowThreads(__tstate);
19948 if (PyErr_Occurred()) SWIG_fail;
19949 }
19950 Py_INCREF(Py_None); resultobj = Py_None;
19951 return resultobj;
19952 fail:
19953 return NULL;
19954 }
19955
19956
19957 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19958 PyObject *resultobj;
19959 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19960 bool result;
19961 PyObject * obj0 = 0 ;
19962 char *kwnames[] = {
19963 (char *) "self", NULL
19964 };
19965
19966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 {
19977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19978 }
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19986 PyObject *obj;
19987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19988 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19989 Py_INCREF(obj);
19990 return Py_BuildValue((char *)"");
19991 }
19992 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj;
19994 int arg1 = (int) 0 ;
19995 bool arg2 = (bool) true ;
19996 wxIconizeEvent *result;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "id",(char *) "iconized", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20004 if (obj0) {
20005 {
20006 arg1 = (int)(SWIG_As_int(obj0));
20007 if (SWIG_arg_fail(1)) SWIG_fail;
20008 }
20009 }
20010 if (obj1) {
20011 {
20012 arg2 = (bool)(SWIG_As_bool(obj1));
20013 if (SWIG_arg_fail(2)) SWIG_fail;
20014 }
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20033 bool result;
20034 PyObject * obj0 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "self", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20041 if (SWIG_arg_fail(1)) SWIG_fail;
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)(arg1)->Iconized();
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 {
20050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20051 }
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20059 PyObject *obj;
20060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20061 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20062 Py_INCREF(obj);
20063 return Py_BuildValue((char *)"");
20064 }
20065 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj;
20067 int arg1 = (int) 0 ;
20068 wxMaximizeEvent *result;
20069 PyObject * obj0 = 0 ;
20070 char *kwnames[] = {
20071 (char *) "id", NULL
20072 };
20073
20074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20075 if (obj0) {
20076 {
20077 arg1 = (int)(SWIG_As_int(obj0));
20078 if (SWIG_arg_fail(1)) SWIG_fail;
20079 }
20080 }
20081 {
20082 PyThreadState* __tstate = wxPyBeginAllowThreads();
20083 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20084
20085 wxPyEndAllowThreads(__tstate);
20086 if (PyErr_Occurred()) SWIG_fail;
20087 }
20088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20096 PyObject *obj;
20097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20098 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20099 Py_INCREF(obj);
20100 return Py_BuildValue((char *)"");
20101 }
20102 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20105 wxPoint result;
20106 PyObject * obj0 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "self", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 {
20115 PyThreadState* __tstate = wxPyBeginAllowThreads();
20116 result = (arg1)->GetPosition();
20117
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 {
20122 wxPoint * resultptr;
20123 resultptr = new wxPoint((wxPoint &)(result));
20124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20135 int result;
20136 PyObject * obj0 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (int)(arg1)->GetNumberOfFiles();
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = SWIG_From_int((int)(result));
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20161 PyObject *resultobj;
20162 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20163 PyObject *result;
20164 PyObject * obj0 = 0 ;
20165 char *kwnames[] = {
20166 (char *) "self", NULL
20167 };
20168
20169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20171 if (SWIG_arg_fail(1)) SWIG_fail;
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20175
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 resultobj = result;
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20187 PyObject *obj;
20188 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20189 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20190 Py_INCREF(obj);
20191 return Py_BuildValue((char *)"");
20192 }
20193 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20194 PyObject *resultobj;
20195 int arg1 = (int) 0 ;
20196 wxUpdateUIEvent *result;
20197 PyObject * obj0 = 0 ;
20198 char *kwnames[] = {
20199 (char *) "commandId", NULL
20200 };
20201
20202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20203 if (obj0) {
20204 {
20205 arg1 = (int)(SWIG_As_int(obj0));
20206 if (SWIG_arg_fail(1)) SWIG_fail;
20207 }
20208 }
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20212
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20224 PyObject *resultobj;
20225 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20226 bool result;
20227 PyObject * obj0 = 0 ;
20228 char *kwnames[] = {
20229 (char *) "self", NULL
20230 };
20231
20232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20234 if (SWIG_arg_fail(1)) SWIG_fail;
20235 {
20236 PyThreadState* __tstate = wxPyBeginAllowThreads();
20237 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20238
20239 wxPyEndAllowThreads(__tstate);
20240 if (PyErr_Occurred()) SWIG_fail;
20241 }
20242 {
20243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20244 }
20245 return resultobj;
20246 fail:
20247 return NULL;
20248 }
20249
20250
20251 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20252 PyObject *resultobj;
20253 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20254 bool result;
20255 PyObject * obj0 = 0 ;
20256 char *kwnames[] = {
20257 (char *) "self", NULL
20258 };
20259
20260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20262 if (SWIG_arg_fail(1)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20266
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 {
20271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj;
20281 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20282 wxString result;
20283 PyObject * obj0 = 0 ;
20284 char *kwnames[] = {
20285 (char *) "self", NULL
20286 };
20287
20288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20290 if (SWIG_arg_fail(1)) SWIG_fail;
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 {
20299 #if wxUSE_UNICODE
20300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20301 #else
20302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20303 #endif
20304 }
20305 return resultobj;
20306 fail:
20307 return NULL;
20308 }
20309
20310
20311 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj;
20313 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20314 bool result;
20315 PyObject * obj0 = 0 ;
20316 char *kwnames[] = {
20317 (char *) "self", NULL
20318 };
20319
20320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20322 if (SWIG_arg_fail(1)) SWIG_fail;
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20326
20327 wxPyEndAllowThreads(__tstate);
20328 if (PyErr_Occurred()) SWIG_fail;
20329 }
20330 {
20331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20340 PyObject *resultobj;
20341 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20342 bool result;
20343 PyObject * obj0 = 0 ;
20344 char *kwnames[] = {
20345 (char *) "self", NULL
20346 };
20347
20348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20350 if (SWIG_arg_fail(1)) SWIG_fail;
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj;
20369 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20370 bool result;
20371 PyObject * obj0 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20388 }
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20396 PyObject *resultobj;
20397 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20398 bool arg2 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 char *kwnames[] = {
20402 (char *) "self",(char *) "check", NULL
20403 };
20404
20405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20407 if (SWIG_arg_fail(1)) SWIG_fail;
20408 {
20409 arg2 = (bool)(SWIG_As_bool(obj1));
20410 if (SWIG_arg_fail(2)) SWIG_fail;
20411 }
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 (arg1)->Check(arg2);
20415
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 Py_INCREF(Py_None); resultobj = Py_None;
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20427 PyObject *resultobj;
20428 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20429 bool arg2 ;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self",(char *) "enable", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 arg2 = (bool)(SWIG_As_bool(obj1));
20441 if (SWIG_arg_fail(2)) SWIG_fail;
20442 }
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 (arg1)->Enable(arg2);
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 Py_INCREF(Py_None); resultobj = Py_None;
20451 return resultobj;
20452 fail:
20453 return NULL;
20454 }
20455
20456
20457 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20460 wxString *arg2 = 0 ;
20461 bool temp2 = false ;
20462 PyObject * obj0 = 0 ;
20463 PyObject * obj1 = 0 ;
20464 char *kwnames[] = {
20465 (char *) "self",(char *) "text", NULL
20466 };
20467
20468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20470 if (SWIG_arg_fail(1)) SWIG_fail;
20471 {
20472 arg2 = wxString_in_helper(obj1);
20473 if (arg2 == NULL) SWIG_fail;
20474 temp2 = true;
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 (arg1)->SetText((wxString const &)*arg2);
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 Py_INCREF(Py_None); resultobj = Py_None;
20484 {
20485 if (temp2)
20486 delete arg2;
20487 }
20488 return resultobj;
20489 fail:
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return NULL;
20495 }
20496
20497
20498 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj;
20500 long arg1 ;
20501 PyObject * obj0 = 0 ;
20502 char *kwnames[] = {
20503 (char *) "updateInterval", NULL
20504 };
20505
20506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20507 {
20508 arg1 = (long)(SWIG_As_long(obj0));
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 }
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 wxUpdateUIEvent::SetUpdateInterval(arg1);
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 Py_INCREF(Py_None); resultobj = Py_None;
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 long result;
20528 char *kwnames[] = {
20529 NULL
20530 };
20531
20532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = SWIG_From_long((long)(result));
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20550 PyObject *resultobj;
20551 wxWindow *arg1 = (wxWindow *) 0 ;
20552 bool result;
20553 PyObject * obj0 = 0 ;
20554 char *kwnames[] = {
20555 (char *) "win", NULL
20556 };
20557
20558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20560 if (SWIG_arg_fail(1)) SWIG_fail;
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 char *kwnames[] = {
20580 NULL
20581 };
20582
20583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 wxUpdateUIEvent::ResetUpdateTime();
20587
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 Py_INCREF(Py_None); resultobj = Py_None;
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20599 PyObject *resultobj;
20600 wxUpdateUIMode arg1 ;
20601 PyObject * obj0 = 0 ;
20602 char *kwnames[] = {
20603 (char *) "mode", NULL
20604 };
20605
20606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20607 {
20608 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20609 if (SWIG_arg_fail(1)) SWIG_fail;
20610 }
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20614
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 Py_INCREF(Py_None); resultobj = Py_None;
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20626 PyObject *resultobj;
20627 wxUpdateUIMode result;
20628 char *kwnames[] = {
20629 NULL
20630 };
20631
20632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 resultobj = SWIG_From_int((result));
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20648 PyObject *obj;
20649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20650 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20651 Py_INCREF(obj);
20652 return Py_BuildValue((char *)"");
20653 }
20654 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20655 PyObject *resultobj;
20656 wxSysColourChangedEvent *result;
20657 char *kwnames[] = {
20658 NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20665
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20670 return resultobj;
20671 fail:
20672 return NULL;
20673 }
20674
20675
20676 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20677 PyObject *obj;
20678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20679 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20680 Py_INCREF(obj);
20681 return Py_BuildValue((char *)"");
20682 }
20683 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj;
20685 int arg1 = (int) 0 ;
20686 wxWindow *arg2 = (wxWindow *) NULL ;
20687 wxMouseCaptureChangedEvent *result;
20688 PyObject * obj0 = 0 ;
20689 PyObject * obj1 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "winid",(char *) "gainedCapture", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20695 if (obj0) {
20696 {
20697 arg1 = (int)(SWIG_As_int(obj0));
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 }
20700 }
20701 if (obj1) {
20702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(2)) SWIG_fail;
20704 }
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj;
20721 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20722 wxWindow *result;
20723 PyObject * obj0 = 0 ;
20724 char *kwnames[] = {
20725 (char *) "self", NULL
20726 };
20727
20728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20730 if (SWIG_arg_fail(1)) SWIG_fail;
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20734
20735 wxPyEndAllowThreads(__tstate);
20736 if (PyErr_Occurred()) SWIG_fail;
20737 }
20738 {
20739 resultobj = wxPyMake_wxObject(result, 0);
20740 }
20741 return resultobj;
20742 fail:
20743 return NULL;
20744 }
20745
20746
20747 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20748 PyObject *obj;
20749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20750 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20751 Py_INCREF(obj);
20752 return Py_BuildValue((char *)"");
20753 }
20754 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20755 PyObject *resultobj;
20756 wxDisplayChangedEvent *result;
20757 char *kwnames[] = {
20758 NULL
20759 };
20760
20761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20777 PyObject *obj;
20778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20779 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20780 Py_INCREF(obj);
20781 return Py_BuildValue((char *)"");
20782 }
20783 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj;
20785 int arg1 = (int) 0 ;
20786 wxPaletteChangedEvent *result;
20787 PyObject * obj0 = 0 ;
20788 char *kwnames[] = {
20789 (char *) "id", NULL
20790 };
20791
20792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20793 if (obj0) {
20794 {
20795 arg1 = (int)(SWIG_As_int(obj0));
20796 if (SWIG_arg_fail(1)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj;
20815 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20816 wxWindow *arg2 = (wxWindow *) 0 ;
20817 PyObject * obj0 = 0 ;
20818 PyObject * obj1 = 0 ;
20819 char *kwnames[] = {
20820 (char *) "self",(char *) "win", NULL
20821 };
20822
20823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20825 if (SWIG_arg_fail(1)) SWIG_fail;
20826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20827 if (SWIG_arg_fail(2)) SWIG_fail;
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 (arg1)->SetChangedWindow(arg2);
20831
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 Py_INCREF(Py_None); resultobj = Py_None;
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj;
20844 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20845 wxWindow *result;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (wxWindow *)(arg1)->GetChangedWindow();
20857
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 {
20862 resultobj = wxPyMake_wxObject(result, 0);
20863 }
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20871 PyObject *obj;
20872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20873 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20874 Py_INCREF(obj);
20875 return Py_BuildValue((char *)"");
20876 }
20877 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 int arg1 = (int) 0 ;
20880 wxQueryNewPaletteEvent *result;
20881 PyObject * obj0 = 0 ;
20882 char *kwnames[] = {
20883 (char *) "winid", NULL
20884 };
20885
20886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20887 if (obj0) {
20888 {
20889 arg1 = (int)(SWIG_As_int(obj0));
20890 if (SWIG_arg_fail(1)) SWIG_fail;
20891 }
20892 }
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20896
20897 wxPyEndAllowThreads(__tstate);
20898 if (PyErr_Occurred()) SWIG_fail;
20899 }
20900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20901 return resultobj;
20902 fail:
20903 return NULL;
20904 }
20905
20906
20907 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20908 PyObject *resultobj;
20909 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20910 bool arg2 ;
20911 PyObject * obj0 = 0 ;
20912 PyObject * obj1 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self",(char *) "realized", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 {
20921 arg2 = (bool)(SWIG_As_bool(obj1));
20922 if (SWIG_arg_fail(2)) SWIG_fail;
20923 }
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 (arg1)->SetPaletteRealized(arg2);
20927
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 Py_INCREF(Py_None); resultobj = Py_None;
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj;
20940 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20941 bool result;
20942 PyObject * obj0 = 0 ;
20943 char *kwnames[] = {
20944 (char *) "self", NULL
20945 };
20946
20947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20949 if (SWIG_arg_fail(1)) SWIG_fail;
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20967 PyObject *obj;
20968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20969 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20970 Py_INCREF(obj);
20971 return Py_BuildValue((char *)"");
20972 }
20973 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20974 PyObject *resultobj;
20975 wxNavigationKeyEvent *result;
20976 char *kwnames[] = {
20977 NULL
20978 };
20979
20980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20984
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20998 bool result;
20999 PyObject * obj0 = 0 ;
21000 char *kwnames[] = {
21001 (char *) "self", NULL
21002 };
21003
21004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21006 if (SWIG_arg_fail(1)) SWIG_fail;
21007 {
21008 PyThreadState* __tstate = wxPyBeginAllowThreads();
21009 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21010
21011 wxPyEndAllowThreads(__tstate);
21012 if (PyErr_Occurred()) SWIG_fail;
21013 }
21014 {
21015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21016 }
21017 return resultobj;
21018 fail:
21019 return NULL;
21020 }
21021
21022
21023 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21024 PyObject *resultobj;
21025 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21026 bool arg2 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 char *kwnames[] = {
21030 (char *) "self",(char *) "forward", NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 {
21037 arg2 = (bool)(SWIG_As_bool(obj1));
21038 if (SWIG_arg_fail(2)) SWIG_fail;
21039 }
21040 {
21041 PyThreadState* __tstate = wxPyBeginAllowThreads();
21042 (arg1)->SetDirection(arg2);
21043
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 Py_INCREF(Py_None); resultobj = Py_None;
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21055 PyObject *resultobj;
21056 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21057 bool result;
21058 PyObject * obj0 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21075 }
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21083 PyObject *resultobj;
21084 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21085 bool arg2 ;
21086 PyObject * obj0 = 0 ;
21087 PyObject * obj1 = 0 ;
21088 char *kwnames[] = {
21089 (char *) "self",(char *) "ischange", NULL
21090 };
21091
21092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21094 if (SWIG_arg_fail(1)) SWIG_fail;
21095 {
21096 arg2 = (bool)(SWIG_As_bool(obj1));
21097 if (SWIG_arg_fail(2)) SWIG_fail;
21098 }
21099 {
21100 PyThreadState* __tstate = wxPyBeginAllowThreads();
21101 (arg1)->SetWindowChange(arg2);
21102
21103 wxPyEndAllowThreads(__tstate);
21104 if (PyErr_Occurred()) SWIG_fail;
21105 }
21106 Py_INCREF(Py_None); resultobj = Py_None;
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21114 PyObject *resultobj;
21115 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21116 long arg2 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self",(char *) "flags", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 arg2 = (long)(SWIG_As_long(obj1));
21128 if (SWIG_arg_fail(2)) SWIG_fail;
21129 }
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 (arg1)->SetFlags(arg2);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 Py_INCREF(Py_None); resultobj = Py_None;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21145 PyObject *resultobj;
21146 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21147 wxWindow *result;
21148 PyObject * obj0 = 0 ;
21149 char *kwnames[] = {
21150 (char *) "self", NULL
21151 };
21152
21153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21155 if (SWIG_arg_fail(1)) SWIG_fail;
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 resultobj = wxPyMake_wxObject(result, 0);
21165 }
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj;
21174 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21175 wxWindow *arg2 = (wxWindow *) 0 ;
21176 PyObject * obj0 = 0 ;
21177 PyObject * obj1 = 0 ;
21178 char *kwnames[] = {
21179 (char *) "self",(char *) "win", NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(1)) SWIG_fail;
21185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(2)) SWIG_fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 (arg1)->SetCurrentFocus(arg2);
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 Py_INCREF(Py_None); resultobj = Py_None;
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21202 PyObject *obj;
21203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21204 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21205 Py_INCREF(obj);
21206 return Py_BuildValue((char *)"");
21207 }
21208 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21209 PyObject *resultobj;
21210 wxWindow *arg1 = (wxWindow *) NULL ;
21211 wxWindowCreateEvent *result;
21212 PyObject * obj0 = 0 ;
21213 char *kwnames[] = {
21214 (char *) "win", NULL
21215 };
21216
21217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21218 if (obj0) {
21219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21220 if (SWIG_arg_fail(1)) SWIG_fail;
21221 }
21222 {
21223 PyThreadState* __tstate = wxPyBeginAllowThreads();
21224 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21225
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21230 return resultobj;
21231 fail:
21232 return NULL;
21233 }
21234
21235
21236 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21239 wxWindow *result;
21240 PyObject * obj0 = 0 ;
21241 char *kwnames[] = {
21242 (char *) "self", NULL
21243 };
21244
21245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21247 if (SWIG_arg_fail(1)) SWIG_fail;
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21251
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 {
21256 resultobj = wxPyMake_wxObject(result, 0);
21257 }
21258 return resultobj;
21259 fail:
21260 return NULL;
21261 }
21262
21263
21264 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21265 PyObject *obj;
21266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21267 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21268 Py_INCREF(obj);
21269 return Py_BuildValue((char *)"");
21270 }
21271 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj;
21273 wxWindow *arg1 = (wxWindow *) NULL ;
21274 wxWindowDestroyEvent *result;
21275 PyObject * obj0 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "win", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21281 if (obj0) {
21282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21283 if (SWIG_arg_fail(1)) SWIG_fail;
21284 }
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21288
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21300 PyObject *resultobj;
21301 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21302 wxWindow *result;
21303 PyObject * obj0 = 0 ;
21304 char *kwnames[] = {
21305 (char *) "self", NULL
21306 };
21307
21308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21310 if (SWIG_arg_fail(1)) SWIG_fail;
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21314
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 {
21319 resultobj = wxPyMake_wxObject(result, 0);
21320 }
21321 return resultobj;
21322 fail:
21323 return NULL;
21324 }
21325
21326
21327 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21328 PyObject *obj;
21329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21330 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21331 Py_INCREF(obj);
21332 return Py_BuildValue((char *)"");
21333 }
21334 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21335 PyObject *resultobj;
21336 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21337 int arg2 = (int) 0 ;
21338 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21339 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21340 wxContextMenuEvent *result;
21341 wxPoint temp3 ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 PyObject * obj2 = 0 ;
21345 char *kwnames[] = {
21346 (char *) "type",(char *) "winid",(char *) "pt", NULL
21347 };
21348
21349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21350 if (obj0) {
21351 {
21352 arg1 = (wxEventType)(SWIG_As_int(obj0));
21353 if (SWIG_arg_fail(1)) SWIG_fail;
21354 }
21355 }
21356 if (obj1) {
21357 {
21358 arg2 = (int)(SWIG_As_int(obj1));
21359 if (SWIG_arg_fail(2)) SWIG_fail;
21360 }
21361 }
21362 if (obj2) {
21363 {
21364 arg3 = &temp3;
21365 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21366 }
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj;
21384 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21385 wxPoint *result;
21386 PyObject * obj0 = 0 ;
21387 char *kwnames[] = {
21388 (char *) "self", NULL
21389 };
21390
21391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21393 if (SWIG_arg_fail(1)) SWIG_fail;
21394 {
21395 PyThreadState* __tstate = wxPyBeginAllowThreads();
21396 {
21397 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21398 result = (wxPoint *) &_result_ref;
21399 }
21400
21401 wxPyEndAllowThreads(__tstate);
21402 if (PyErr_Occurred()) SWIG_fail;
21403 }
21404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21414 wxPoint *arg2 = 0 ;
21415 wxPoint temp2 ;
21416 PyObject * obj0 = 0 ;
21417 PyObject * obj1 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self",(char *) "pos", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 {
21426 arg2 = &temp2;
21427 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21428 }
21429 {
21430 PyThreadState* __tstate = wxPyBeginAllowThreads();
21431 (arg1)->SetPosition((wxPoint const &)*arg2);
21432
21433 wxPyEndAllowThreads(__tstate);
21434 if (PyErr_Occurred()) SWIG_fail;
21435 }
21436 Py_INCREF(Py_None); resultobj = Py_None;
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21444 PyObject *obj;
21445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21446 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21447 Py_INCREF(obj);
21448 return Py_BuildValue((char *)"");
21449 }
21450 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21451 PyObject *resultobj;
21452 wxIdleEvent *result;
21453 char *kwnames[] = {
21454 NULL
21455 };
21456
21457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 result = (wxIdleEvent *)new wxIdleEvent();
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21473 PyObject *resultobj;
21474 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21475 bool arg2 = (bool) true ;
21476 PyObject * obj0 = 0 ;
21477 PyObject * obj1 = 0 ;
21478 char *kwnames[] = {
21479 (char *) "self",(char *) "needMore", NULL
21480 };
21481
21482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21484 if (SWIG_arg_fail(1)) SWIG_fail;
21485 if (obj1) {
21486 {
21487 arg2 = (bool)(SWIG_As_bool(obj1));
21488 if (SWIG_arg_fail(2)) SWIG_fail;
21489 }
21490 }
21491 {
21492 PyThreadState* __tstate = wxPyBeginAllowThreads();
21493 (arg1)->RequestMore(arg2);
21494
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 Py_INCREF(Py_None); resultobj = Py_None;
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21506 PyObject *resultobj;
21507 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21508 bool result;
21509 PyObject * obj0 = 0 ;
21510 char *kwnames[] = {
21511 (char *) "self", NULL
21512 };
21513
21514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21516 if (SWIG_arg_fail(1)) SWIG_fail;
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21520
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 {
21525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21526 }
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj;
21535 wxIdleMode arg1 ;
21536 PyObject * obj0 = 0 ;
21537 char *kwnames[] = {
21538 (char *) "mode", NULL
21539 };
21540
21541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21542 {
21543 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21544 if (SWIG_arg_fail(1)) SWIG_fail;
21545 }
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 wxIdleEvent::SetMode((wxIdleMode )arg1);
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 Py_INCREF(Py_None); resultobj = Py_None;
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxIdleMode result;
21563 char *kwnames[] = {
21564 NULL
21565 };
21566
21567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 result = (wxIdleMode)wxIdleEvent::GetMode();
21571
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 resultobj = SWIG_From_int((result));
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxWindow *arg1 = (wxWindow *) 0 ;
21585 bool result;
21586 PyObject * obj0 = 0 ;
21587 char *kwnames[] = {
21588 (char *) "win", NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21593 if (SWIG_arg_fail(1)) SWIG_fail;
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (bool)wxIdleEvent::CanSend(arg1);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21603 }
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21611 PyObject *obj;
21612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21613 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21614 Py_INCREF(obj);
21615 return Py_BuildValue((char *)"");
21616 }
21617 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj;
21619 int arg1 = (int) 0 ;
21620 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21621 wxPyEvent *result;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 char *kwnames[] = {
21625 (char *) "winid",(char *) "commandType", NULL
21626 };
21627
21628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21629 if (obj0) {
21630 {
21631 arg1 = (int)(SWIG_As_int(obj0));
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 }
21634 }
21635 if (obj1) {
21636 {
21637 arg2 = (wxEventType)(SWIG_As_int(obj1));
21638 if (SWIG_arg_fail(2)) SWIG_fail;
21639 }
21640 }
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj;
21657 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21658 PyObject * obj0 = 0 ;
21659 char *kwnames[] = {
21660 (char *) "self", NULL
21661 };
21662
21663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21665 if (SWIG_arg_fail(1)) SWIG_fail;
21666 {
21667 PyThreadState* __tstate = wxPyBeginAllowThreads();
21668 delete arg1;
21669
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 Py_INCREF(Py_None); resultobj = Py_None;
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj;
21682 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21683 PyObject *arg2 = (PyObject *) 0 ;
21684 PyObject * obj0 = 0 ;
21685 PyObject * obj1 = 0 ;
21686 char *kwnames[] = {
21687 (char *) "self",(char *) "self", NULL
21688 };
21689
21690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21692 if (SWIG_arg_fail(1)) SWIG_fail;
21693 arg2 = obj1;
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 (arg1)->SetSelf(arg2);
21697
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 Py_INCREF(Py_None); resultobj = Py_None;
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj;
21710 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21711 PyObject *result;
21712 PyObject * obj0 = 0 ;
21713 char *kwnames[] = {
21714 (char *) "self", NULL
21715 };
21716
21717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21719 if (SWIG_arg_fail(1)) SWIG_fail;
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (PyObject *)(arg1)->GetSelf();
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 resultobj = result;
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21735 PyObject *obj;
21736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21737 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21738 Py_INCREF(obj);
21739 return Py_BuildValue((char *)"");
21740 }
21741 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj;
21743 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21744 int arg2 = (int) 0 ;
21745 wxPyCommandEvent *result;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char *kwnames[] = {
21749 (char *) "commandType",(char *) "id", NULL
21750 };
21751
21752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21753 if (obj0) {
21754 {
21755 arg1 = (wxEventType)(SWIG_As_int(obj0));
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 }
21758 }
21759 if (obj1) {
21760 {
21761 arg2 = (int)(SWIG_As_int(obj1));
21762 if (SWIG_arg_fail(2)) SWIG_fail;
21763 }
21764 }
21765 {
21766 PyThreadState* __tstate = wxPyBeginAllowThreads();
21767 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21768
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21780 PyObject *resultobj;
21781 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21782 PyObject * obj0 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 delete arg1;
21793
21794 wxPyEndAllowThreads(__tstate);
21795 if (PyErr_Occurred()) SWIG_fail;
21796 }
21797 Py_INCREF(Py_None); resultobj = Py_None;
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21805 PyObject *resultobj;
21806 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21807 PyObject *arg2 = (PyObject *) 0 ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 char *kwnames[] = {
21811 (char *) "self",(char *) "self", NULL
21812 };
21813
21814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 arg2 = obj1;
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 (arg1)->SetSelf(arg2);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 Py_INCREF(Py_None); resultobj = Py_None;
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21835 PyObject *result;
21836 PyObject * obj0 = 0 ;
21837 char *kwnames[] = {
21838 (char *) "self", NULL
21839 };
21840
21841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (PyObject *)(arg1)->GetSelf();
21847
21848 wxPyEndAllowThreads(__tstate);
21849 if (PyErr_Occurred()) SWIG_fail;
21850 }
21851 resultobj = result;
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21859 PyObject *obj;
21860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21861 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21862 Py_INCREF(obj);
21863 return Py_BuildValue((char *)"");
21864 }
21865 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21866 PyObject *resultobj;
21867 wxPyApp *result;
21868 char *kwnames[] = {
21869 NULL
21870 };
21871
21872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (wxPyApp *)new_wxPyApp();
21876
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21888 PyObject *resultobj;
21889 wxPyApp *arg1 = (wxPyApp *) 0 ;
21890 PyObject * obj0 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 delete arg1;
21901
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 Py_INCREF(Py_None); resultobj = Py_None;
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21913 PyObject *resultobj;
21914 wxPyApp *arg1 = (wxPyApp *) 0 ;
21915 PyObject *arg2 = (PyObject *) 0 ;
21916 PyObject *arg3 = (PyObject *) 0 ;
21917 PyObject * obj0 = 0 ;
21918 PyObject * obj1 = 0 ;
21919 PyObject * obj2 = 0 ;
21920 char *kwnames[] = {
21921 (char *) "self",(char *) "self",(char *) "_class", NULL
21922 };
21923
21924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(1)) SWIG_fail;
21927 arg2 = obj1;
21928 arg3 = obj2;
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 (arg1)->_setCallbackInfo(arg2,arg3);
21932
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 Py_INCREF(Py_None); resultobj = Py_None;
21937 return resultobj;
21938 fail:
21939 return NULL;
21940 }
21941
21942
21943 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj;
21945 wxPyApp *arg1 = (wxPyApp *) 0 ;
21946 wxString result;
21947 PyObject * obj0 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = ((wxPyApp const *)arg1)->GetAppName();
21958
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 {
21963 #if wxUSE_UNICODE
21964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21965 #else
21966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21967 #endif
21968 }
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21976 PyObject *resultobj;
21977 wxPyApp *arg1 = (wxPyApp *) 0 ;
21978 wxString *arg2 = 0 ;
21979 bool temp2 = false ;
21980 PyObject * obj0 = 0 ;
21981 PyObject * obj1 = 0 ;
21982 char *kwnames[] = {
21983 (char *) "self",(char *) "name", NULL
21984 };
21985
21986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21988 if (SWIG_arg_fail(1)) SWIG_fail;
21989 {
21990 arg2 = wxString_in_helper(obj1);
21991 if (arg2 == NULL) SWIG_fail;
21992 temp2 = true;
21993 }
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 (arg1)->SetAppName((wxString const &)*arg2);
21997
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 Py_INCREF(Py_None); resultobj = Py_None;
22002 {
22003 if (temp2)
22004 delete arg2;
22005 }
22006 return resultobj;
22007 fail:
22008 {
22009 if (temp2)
22010 delete arg2;
22011 }
22012 return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj;
22018 wxPyApp *arg1 = (wxPyApp *) 0 ;
22019 wxString result;
22020 PyObject * obj0 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 result = ((wxPyApp const *)arg1)->GetClassName();
22031
22032 wxPyEndAllowThreads(__tstate);
22033 if (PyErr_Occurred()) SWIG_fail;
22034 }
22035 {
22036 #if wxUSE_UNICODE
22037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22038 #else
22039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22040 #endif
22041 }
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj;
22050 wxPyApp *arg1 = (wxPyApp *) 0 ;
22051 wxString *arg2 = 0 ;
22052 bool temp2 = false ;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 char *kwnames[] = {
22056 (char *) "self",(char *) "name", NULL
22057 };
22058
22059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22061 if (SWIG_arg_fail(1)) SWIG_fail;
22062 {
22063 arg2 = wxString_in_helper(obj1);
22064 if (arg2 == NULL) SWIG_fail;
22065 temp2 = true;
22066 }
22067 {
22068 PyThreadState* __tstate = wxPyBeginAllowThreads();
22069 (arg1)->SetClassName((wxString const &)*arg2);
22070
22071 wxPyEndAllowThreads(__tstate);
22072 if (PyErr_Occurred()) SWIG_fail;
22073 }
22074 Py_INCREF(Py_None); resultobj = Py_None;
22075 {
22076 if (temp2)
22077 delete arg2;
22078 }
22079 return resultobj;
22080 fail:
22081 {
22082 if (temp2)
22083 delete arg2;
22084 }
22085 return NULL;
22086 }
22087
22088
22089 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22090 PyObject *resultobj;
22091 wxPyApp *arg1 = (wxPyApp *) 0 ;
22092 wxString *result;
22093 PyObject * obj0 = 0 ;
22094 char *kwnames[] = {
22095 (char *) "self", NULL
22096 };
22097
22098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22100 if (SWIG_arg_fail(1)) SWIG_fail;
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 {
22104 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22105 result = (wxString *) &_result_ref;
22106 }
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 {
22112 #if wxUSE_UNICODE
22113 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22114 #else
22115 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22116 #endif
22117 }
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22125 PyObject *resultobj;
22126 wxPyApp *arg1 = (wxPyApp *) 0 ;
22127 wxString *arg2 = 0 ;
22128 bool temp2 = false ;
22129 PyObject * obj0 = 0 ;
22130 PyObject * obj1 = 0 ;
22131 char *kwnames[] = {
22132 (char *) "self",(char *) "name", NULL
22133 };
22134
22135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22137 if (SWIG_arg_fail(1)) SWIG_fail;
22138 {
22139 arg2 = wxString_in_helper(obj1);
22140 if (arg2 == NULL) SWIG_fail;
22141 temp2 = true;
22142 }
22143 {
22144 PyThreadState* __tstate = wxPyBeginAllowThreads();
22145 (arg1)->SetVendorName((wxString const &)*arg2);
22146
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 Py_INCREF(Py_None); resultobj = Py_None;
22151 {
22152 if (temp2)
22153 delete arg2;
22154 }
22155 return resultobj;
22156 fail:
22157 {
22158 if (temp2)
22159 delete arg2;
22160 }
22161 return NULL;
22162 }
22163
22164
22165 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22166 PyObject *resultobj;
22167 wxPyApp *arg1 = (wxPyApp *) 0 ;
22168 wxAppTraits *result;
22169 PyObject * obj0 = 0 ;
22170 char *kwnames[] = {
22171 (char *) "self", NULL
22172 };
22173
22174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22176 if (SWIG_arg_fail(1)) SWIG_fail;
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (wxAppTraits *)(arg1)->GetTraits();
22180
22181 wxPyEndAllowThreads(__tstate);
22182 if (PyErr_Occurred()) SWIG_fail;
22183 }
22184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22185 return resultobj;
22186 fail:
22187 return NULL;
22188 }
22189
22190
22191 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22192 PyObject *resultobj;
22193 wxPyApp *arg1 = (wxPyApp *) 0 ;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",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 (arg1)->ProcessPendingEvents();
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 Py_INCREF(Py_None); resultobj = Py_None;
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj;
22218 wxPyApp *arg1 = (wxPyApp *) 0 ;
22219 bool arg2 = (bool) false ;
22220 bool result;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 char *kwnames[] = {
22224 (char *) "self",(char *) "onlyIfNeeded", NULL
22225 };
22226
22227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22229 if (SWIG_arg_fail(1)) SWIG_fail;
22230 if (obj1) {
22231 {
22232 arg2 = (bool)(SWIG_As_bool(obj1));
22233 if (SWIG_arg_fail(2)) SWIG_fail;
22234 }
22235 }
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (bool)(arg1)->Yield(arg2);
22239
22240 wxPyEndAllowThreads(__tstate);
22241 if (PyErr_Occurred()) SWIG_fail;
22242 }
22243 {
22244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22253 PyObject *resultobj;
22254 wxPyApp *arg1 = (wxPyApp *) 0 ;
22255 PyObject * obj0 = 0 ;
22256 char *kwnames[] = {
22257 (char *) "self", NULL
22258 };
22259
22260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22262 if (SWIG_arg_fail(1)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 (arg1)->WakeUpIdle();
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 Py_INCREF(Py_None); resultobj = Py_None;
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj;
22279 bool result;
22280 char *kwnames[] = {
22281 NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 result = (bool)wxPyApp::IsMainLoopRunning();
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 {
22293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22294 }
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22302 PyObject *resultobj;
22303 wxPyApp *arg1 = (wxPyApp *) 0 ;
22304 int result;
22305 PyObject * obj0 = 0 ;
22306 char *kwnames[] = {
22307 (char *) "self", NULL
22308 };
22309
22310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22312 if (SWIG_arg_fail(1)) SWIG_fail;
22313 {
22314 PyThreadState* __tstate = wxPyBeginAllowThreads();
22315 result = (int)(arg1)->MainLoop();
22316
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = SWIG_From_int((int)(result));
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj;
22331 wxPyApp *arg1 = (wxPyApp *) 0 ;
22332 PyObject * obj0 = 0 ;
22333 char *kwnames[] = {
22334 (char *) "self", NULL
22335 };
22336
22337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(1)) SWIG_fail;
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 (arg1)->Exit();
22343
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 Py_INCREF(Py_None); resultobj = Py_None;
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj;
22356 wxPyApp *arg1 = (wxPyApp *) 0 ;
22357 PyObject * obj0 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 (arg1)->ExitMainLoop();
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 Py_INCREF(Py_None); resultobj = Py_None;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxPyApp *arg1 = (wxPyApp *) 0 ;
22382 bool result;
22383 PyObject * obj0 = 0 ;
22384 char *kwnames[] = {
22385 (char *) "self", NULL
22386 };
22387
22388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 result = (bool)(arg1)->Pending();
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 {
22399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22400 }
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22408 PyObject *resultobj;
22409 wxPyApp *arg1 = (wxPyApp *) 0 ;
22410 bool result;
22411 PyObject * obj0 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "self", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (bool)(arg1)->Dispatch();
22422
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 {
22427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22428 }
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22436 PyObject *resultobj;
22437 wxPyApp *arg1 = (wxPyApp *) 0 ;
22438 bool result;
22439 PyObject * obj0 = 0 ;
22440 char *kwnames[] = {
22441 (char *) "self", NULL
22442 };
22443
22444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(1)) SWIG_fail;
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (bool)(arg1)->ProcessIdle();
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 {
22455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22456 }
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj;
22465 wxPyApp *arg1 = (wxPyApp *) 0 ;
22466 wxWindow *arg2 = (wxWindow *) 0 ;
22467 wxIdleEvent *arg3 = 0 ;
22468 bool result;
22469 PyObject * obj0 = 0 ;
22470 PyObject * obj1 = 0 ;
22471 PyObject * obj2 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "win",(char *) "event", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 {
22482 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(3)) SWIG_fail;
22484 if (arg3 == NULL) {
22485 SWIG_null_ref("wxIdleEvent");
22486 }
22487 if (SWIG_arg_fail(3)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 {
22497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22498 }
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj;
22507 wxPyApp *arg1 = (wxPyApp *) 0 ;
22508 bool result;
22509 PyObject * obj0 = 0 ;
22510 char *kwnames[] = {
22511 (char *) "self", NULL
22512 };
22513
22514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22516 if (SWIG_arg_fail(1)) SWIG_fail;
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 result = (bool)((wxPyApp const *)arg1)->IsActive();
22520
22521 wxPyEndAllowThreads(__tstate);
22522 if (PyErr_Occurred()) SWIG_fail;
22523 }
22524 {
22525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22526 }
22527 return resultobj;
22528 fail:
22529 return NULL;
22530 }
22531
22532
22533 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22534 PyObject *resultobj;
22535 wxPyApp *arg1 = (wxPyApp *) 0 ;
22536 wxWindow *arg2 = (wxWindow *) 0 ;
22537 PyObject * obj0 = 0 ;
22538 PyObject * obj1 = 0 ;
22539 char *kwnames[] = {
22540 (char *) "self",(char *) "win", NULL
22541 };
22542
22543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(1)) SWIG_fail;
22546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 {
22549 PyThreadState* __tstate = wxPyBeginAllowThreads();
22550 (arg1)->SetTopWindow(arg2);
22551
22552 wxPyEndAllowThreads(__tstate);
22553 if (PyErr_Occurred()) SWIG_fail;
22554 }
22555 Py_INCREF(Py_None); resultobj = Py_None;
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj;
22564 wxPyApp *arg1 = (wxPyApp *) 0 ;
22565 wxWindow *result;
22566 PyObject * obj0 = 0 ;
22567 char *kwnames[] = {
22568 (char *) "self", NULL
22569 };
22570
22571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22573 if (SWIG_arg_fail(1)) SWIG_fail;
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22577
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 {
22582 resultobj = wxPyMake_wxObject(result, 0);
22583 }
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj;
22592 wxPyApp *arg1 = (wxPyApp *) 0 ;
22593 bool arg2 ;
22594 PyObject * obj0 = 0 ;
22595 PyObject * obj1 = 0 ;
22596 char *kwnames[] = {
22597 (char *) "self",(char *) "flag", NULL
22598 };
22599
22600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22602 if (SWIG_arg_fail(1)) SWIG_fail;
22603 {
22604 arg2 = (bool)(SWIG_As_bool(obj1));
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 }
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 (arg1)->SetExitOnFrameDelete(arg2);
22610
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 Py_INCREF(Py_None); resultobj = Py_None;
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj;
22623 wxPyApp *arg1 = (wxPyApp *) 0 ;
22624 bool result;
22625 PyObject * obj0 = 0 ;
22626 char *kwnames[] = {
22627 (char *) "self", NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22632 if (SWIG_arg_fail(1)) SWIG_fail;
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22636
22637 wxPyEndAllowThreads(__tstate);
22638 if (PyErr_Occurred()) SWIG_fail;
22639 }
22640 {
22641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22642 }
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxPyApp *arg1 = (wxPyApp *) 0 ;
22652 bool arg2 ;
22653 PyObject * obj0 = 0 ;
22654 PyObject * obj1 = 0 ;
22655 char *kwnames[] = {
22656 (char *) "self",(char *) "flag", NULL
22657 };
22658
22659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22661 if (SWIG_arg_fail(1)) SWIG_fail;
22662 {
22663 arg2 = (bool)(SWIG_As_bool(obj1));
22664 if (SWIG_arg_fail(2)) SWIG_fail;
22665 }
22666 {
22667 PyThreadState* __tstate = wxPyBeginAllowThreads();
22668 (arg1)->SetUseBestVisual(arg2);
22669
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 Py_INCREF(Py_None); resultobj = Py_None;
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22681 PyObject *resultobj;
22682 wxPyApp *arg1 = (wxPyApp *) 0 ;
22683 bool result;
22684 PyObject * obj0 = 0 ;
22685 char *kwnames[] = {
22686 (char *) "self", NULL
22687 };
22688
22689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22691 if (SWIG_arg_fail(1)) SWIG_fail;
22692 {
22693 PyThreadState* __tstate = wxPyBeginAllowThreads();
22694 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22695
22696 wxPyEndAllowThreads(__tstate);
22697 if (PyErr_Occurred()) SWIG_fail;
22698 }
22699 {
22700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22701 }
22702 return resultobj;
22703 fail:
22704 return NULL;
22705 }
22706
22707
22708 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22709 PyObject *resultobj;
22710 wxPyApp *arg1 = (wxPyApp *) 0 ;
22711 int arg2 ;
22712 PyObject * obj0 = 0 ;
22713 PyObject * obj1 = 0 ;
22714 char *kwnames[] = {
22715 (char *) "self",(char *) "mode", NULL
22716 };
22717
22718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22720 if (SWIG_arg_fail(1)) SWIG_fail;
22721 {
22722 arg2 = (int)(SWIG_As_int(obj1));
22723 if (SWIG_arg_fail(2)) SWIG_fail;
22724 }
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 (arg1)->SetPrintMode(arg2);
22728
22729 wxPyEndAllowThreads(__tstate);
22730 if (PyErr_Occurred()) SWIG_fail;
22731 }
22732 Py_INCREF(Py_None); resultobj = Py_None;
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 int result;
22743 PyObject * obj0 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 {
22759 resultobj = SWIG_From_int((int)(result));
22760 }
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22768 PyObject *resultobj;
22769 wxPyApp *arg1 = (wxPyApp *) 0 ;
22770 int arg2 ;
22771 PyObject * obj0 = 0 ;
22772 PyObject * obj1 = 0 ;
22773 char *kwnames[] = {
22774 (char *) "self",(char *) "mode", NULL
22775 };
22776
22777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22779 if (SWIG_arg_fail(1)) SWIG_fail;
22780 {
22781 arg2 = (int)(SWIG_As_int(obj1));
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 }
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 (arg1)->SetAssertMode(arg2);
22787
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 Py_INCREF(Py_None); resultobj = Py_None;
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22799 PyObject *resultobj;
22800 wxPyApp *arg1 = (wxPyApp *) 0 ;
22801 int result;
22802 PyObject * obj0 = 0 ;
22803 char *kwnames[] = {
22804 (char *) "self", NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22809 if (SWIG_arg_fail(1)) SWIG_fail;
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (int)(arg1)->GetAssertMode();
22813
22814 wxPyEndAllowThreads(__tstate);
22815 if (PyErr_Occurred()) SWIG_fail;
22816 }
22817 {
22818 resultobj = SWIG_From_int((int)(result));
22819 }
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22827 PyObject *resultobj;
22828 bool result;
22829 char *kwnames[] = {
22830 NULL
22831 };
22832
22833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22837
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 {
22842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22843 }
22844 return resultobj;
22845 fail:
22846 return NULL;
22847 }
22848
22849
22850 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22851 PyObject *resultobj;
22852 long result;
22853 char *kwnames[] = {
22854 NULL
22855 };
22856
22857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 result = (long)wxPyApp::GetMacAboutMenuItemId();
22861
22862 wxPyEndAllowThreads(__tstate);
22863 if (PyErr_Occurred()) SWIG_fail;
22864 }
22865 {
22866 resultobj = SWIG_From_long((long)(result));
22867 }
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj;
22876 long result;
22877 char *kwnames[] = {
22878 NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 resultobj = SWIG_From_long((long)(result));
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj;
22900 long result;
22901 char *kwnames[] = {
22902 NULL
22903 };
22904
22905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22906 {
22907 PyThreadState* __tstate = wxPyBeginAllowThreads();
22908 result = (long)wxPyApp::GetMacExitMenuItemId();
22909
22910 wxPyEndAllowThreads(__tstate);
22911 if (PyErr_Occurred()) SWIG_fail;
22912 }
22913 {
22914 resultobj = SWIG_From_long((long)(result));
22915 }
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22923 PyObject *resultobj;
22924 wxString result;
22925 char *kwnames[] = {
22926 NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = wxPyApp::GetMacHelpMenuTitleName();
22933
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 {
22938 #if wxUSE_UNICODE
22939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22940 #else
22941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22942 #endif
22943 }
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22951 PyObject *resultobj;
22952 bool arg1 ;
22953 PyObject * obj0 = 0 ;
22954 char *kwnames[] = {
22955 (char *) "val", NULL
22956 };
22957
22958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22959 {
22960 arg1 = (bool)(SWIG_As_bool(obj0));
22961 if (SWIG_arg_fail(1)) SWIG_fail;
22962 }
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22966
22967 wxPyEndAllowThreads(__tstate);
22968 if (PyErr_Occurred()) SWIG_fail;
22969 }
22970 Py_INCREF(Py_None); resultobj = Py_None;
22971 return resultobj;
22972 fail:
22973 return NULL;
22974 }
22975
22976
22977 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22978 PyObject *resultobj;
22979 long arg1 ;
22980 PyObject * obj0 = 0 ;
22981 char *kwnames[] = {
22982 (char *) "val", NULL
22983 };
22984
22985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22986 {
22987 arg1 = (long)(SWIG_As_long(obj0));
22988 if (SWIG_arg_fail(1)) SWIG_fail;
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 wxPyApp::SetMacAboutMenuItemId(arg1);
22993
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 Py_INCREF(Py_None); resultobj = Py_None;
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23005 PyObject *resultobj;
23006 long arg1 ;
23007 PyObject * obj0 = 0 ;
23008 char *kwnames[] = {
23009 (char *) "val", NULL
23010 };
23011
23012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23013 {
23014 arg1 = (long)(SWIG_As_long(obj0));
23015 if (SWIG_arg_fail(1)) SWIG_fail;
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 Py_INCREF(Py_None); resultobj = Py_None;
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23032 PyObject *resultobj;
23033 long arg1 ;
23034 PyObject * obj0 = 0 ;
23035 char *kwnames[] = {
23036 (char *) "val", NULL
23037 };
23038
23039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23040 {
23041 arg1 = (long)(SWIG_As_long(obj0));
23042 if (SWIG_arg_fail(1)) SWIG_fail;
23043 }
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 wxPyApp::SetMacExitMenuItemId(arg1);
23047
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 Py_INCREF(Py_None); resultobj = Py_None;
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 wxString *arg1 = 0 ;
23061 bool temp1 = false ;
23062 PyObject * obj0 = 0 ;
23063 char *kwnames[] = {
23064 (char *) "val", NULL
23065 };
23066
23067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23068 {
23069 arg1 = wxString_in_helper(obj0);
23070 if (arg1 == NULL) SWIG_fail;
23071 temp1 = true;
23072 }
23073 {
23074 PyThreadState* __tstate = wxPyBeginAllowThreads();
23075 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23076
23077 wxPyEndAllowThreads(__tstate);
23078 if (PyErr_Occurred()) SWIG_fail;
23079 }
23080 Py_INCREF(Py_None); resultobj = Py_None;
23081 {
23082 if (temp1)
23083 delete arg1;
23084 }
23085 return resultobj;
23086 fail:
23087 {
23088 if (temp1)
23089 delete arg1;
23090 }
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj;
23097 wxPyApp *arg1 = (wxPyApp *) 0 ;
23098 PyObject * obj0 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 (arg1)->_BootstrapApp();
23109
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 Py_INCREF(Py_None); resultobj = Py_None;
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj;
23122 int result;
23123 char *kwnames[] = {
23124 NULL
23125 };
23126
23127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (int)PyApp_GetComCtl32Version();
23131
23132 wxPyEndAllowThreads(__tstate);
23133 if (PyErr_Occurred()) SWIG_fail;
23134 }
23135 {
23136 resultobj = SWIG_From_int((int)(result));
23137 }
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23145 PyObject *obj;
23146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23147 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23148 Py_INCREF(obj);
23149 return Py_BuildValue((char *)"");
23150 }
23151 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23152 PyObject *resultobj;
23153 char *kwnames[] = {
23154 NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 wxExit();
23161
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 Py_INCREF(Py_None); resultobj = Py_None;
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj;
23174 bool result;
23175 char *kwnames[] = {
23176 NULL
23177 };
23178
23179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 result = (bool)wxYield();
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 {
23188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23189 }
23190 return resultobj;
23191 fail:
23192 return NULL;
23193 }
23194
23195
23196 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj;
23198 bool result;
23199 char *kwnames[] = {
23200 NULL
23201 };
23202
23203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = (bool)wxYieldIfNeeded();
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 {
23212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23213 }
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj;
23222 wxWindow *arg1 = (wxWindow *) NULL ;
23223 bool arg2 = (bool) false ;
23224 bool result;
23225 PyObject * obj0 = 0 ;
23226 PyObject * obj1 = 0 ;
23227 char *kwnames[] = {
23228 (char *) "win",(char *) "onlyIfNeeded", NULL
23229 };
23230
23231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23232 if (obj0) {
23233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(1)) SWIG_fail;
23235 }
23236 if (obj1) {
23237 {
23238 arg2 = (bool)(SWIG_As_bool(obj1));
23239 if (SWIG_arg_fail(2)) SWIG_fail;
23240 }
23241 }
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)wxSafeYield(arg1,arg2);
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 char *kwnames[] = {
23261 NULL
23262 };
23263
23264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 wxWakeUpIdle();
23268
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 Py_INCREF(Py_None); resultobj = Py_None;
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj;
23281 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23282 wxEvent *arg2 = 0 ;
23283 PyObject * obj0 = 0 ;
23284 PyObject * obj1 = 0 ;
23285 char *kwnames[] = {
23286 (char *) "dest",(char *) "event", NULL
23287 };
23288
23289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23291 if (SWIG_arg_fail(1)) SWIG_fail;
23292 {
23293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(2)) SWIG_fail;
23295 if (arg2 == NULL) {
23296 SWIG_null_ref("wxEvent");
23297 }
23298 if (SWIG_arg_fail(2)) SWIG_fail;
23299 }
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 wxPostEvent(arg1,*arg2);
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 Py_INCREF(Py_None); resultobj = Py_None;
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 char *kwnames[] = {
23317 NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 wxApp_CleanUp();
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 Py_INCREF(Py_None); resultobj = Py_None;
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 wxPyApp *result;
23338 char *kwnames[] = {
23339 NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (wxPyApp *)wxPyGetApp();
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 {
23351 resultobj = wxPyMake_wxObject(result, 0);
23352 }
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj;
23361 char *arg1 = (char *) 0 ;
23362 PyObject * obj0 = 0 ;
23363 char *kwnames[] = {
23364 (char *) "encoding", NULL
23365 };
23366
23367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23368 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23369 SWIG_arg_fail(1);SWIG_fail;
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 wxSetDefaultPyEncoding((char const *)arg1);
23374
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 Py_INCREF(Py_None); resultobj = Py_None;
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 char *result;
23388 char *kwnames[] = {
23389 NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (char *)wxGetDefaultPyEncoding();
23396
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 resultobj = SWIG_FromCharPtr(result);
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23408 PyObject *resultobj;
23409 wxEventLoop *result;
23410 char *kwnames[] = {
23411 NULL
23412 };
23413
23414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23415 {
23416 PyThreadState* __tstate = wxPyBeginAllowThreads();
23417 result = (wxEventLoop *)new wxEventLoop();
23418
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23423 return resultobj;
23424 fail:
23425 return NULL;
23426 }
23427
23428
23429 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj;
23431 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23432 PyObject * obj0 = 0 ;
23433 char *kwnames[] = {
23434 (char *) "self", NULL
23435 };
23436
23437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23439 if (SWIG_arg_fail(1)) SWIG_fail;
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 delete arg1;
23443
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 Py_INCREF(Py_None); resultobj = Py_None;
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj;
23456 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23457 int result;
23458 PyObject * obj0 = 0 ;
23459 char *kwnames[] = {
23460 (char *) "self", NULL
23461 };
23462
23463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23465 if (SWIG_arg_fail(1)) SWIG_fail;
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 result = (int)(arg1)->Run();
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 {
23474 resultobj = SWIG_From_int((int)(result));
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23485 int arg2 = (int) 0 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char *kwnames[] = {
23489 (char *) "self",(char *) "rc", NULL
23490 };
23491
23492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23494 if (SWIG_arg_fail(1)) SWIG_fail;
23495 if (obj1) {
23496 {
23497 arg2 = (int)(SWIG_As_int(obj1));
23498 if (SWIG_arg_fail(2)) SWIG_fail;
23499 }
23500 }
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 (arg1)->Exit(arg2);
23504
23505 wxPyEndAllowThreads(__tstate);
23506 if (PyErr_Occurred()) SWIG_fail;
23507 }
23508 Py_INCREF(Py_None); resultobj = Py_None;
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23516 PyObject *resultobj;
23517 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23518 bool result;
23519 PyObject * obj0 = 0 ;
23520 char *kwnames[] = {
23521 (char *) "self", NULL
23522 };
23523
23524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23526 if (SWIG_arg_fail(1)) SWIG_fail;
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = (bool)((wxEventLoop const *)arg1)->Pending();
23530
23531 wxPyEndAllowThreads(__tstate);
23532 if (PyErr_Occurred()) SWIG_fail;
23533 }
23534 {
23535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23536 }
23537 return resultobj;
23538 fail:
23539 return NULL;
23540 }
23541
23542
23543 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23544 PyObject *resultobj;
23545 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23546 bool result;
23547 PyObject * obj0 = 0 ;
23548 char *kwnames[] = {
23549 (char *) "self", NULL
23550 };
23551
23552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23554 if (SWIG_arg_fail(1)) SWIG_fail;
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = (bool)(arg1)->Dispatch();
23558
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 {
23563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23564 }
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj;
23573 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23574 bool result;
23575 PyObject * obj0 = 0 ;
23576 char *kwnames[] = {
23577 (char *) "self", NULL
23578 };
23579
23580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23582 if (SWIG_arg_fail(1)) SWIG_fail;
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23586
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 {
23591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23592 }
23593 return resultobj;
23594 fail:
23595 return NULL;
23596 }
23597
23598
23599 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23600 PyObject *resultobj;
23601 wxEventLoop *result;
23602 char *kwnames[] = {
23603 NULL
23604 };
23605
23606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23607 {
23608 PyThreadState* __tstate = wxPyBeginAllowThreads();
23609 result = (wxEventLoop *)wxEventLoop::GetActive();
23610
23611 wxPyEndAllowThreads(__tstate);
23612 if (PyErr_Occurred()) SWIG_fail;
23613 }
23614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj;
23623 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23624 PyObject * obj0 = 0 ;
23625 char *kwnames[] = {
23626 (char *) "loop", NULL
23627 };
23628
23629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23631 if (SWIG_arg_fail(1)) SWIG_fail;
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 wxEventLoop::SetActive(arg1);
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 Py_INCREF(Py_None); resultobj = Py_None;
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23647 PyObject *obj;
23648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23649 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23650 Py_INCREF(obj);
23651 return Py_BuildValue((char *)"");
23652 }
23653 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23654 PyObject *resultobj;
23655 int arg1 = (int) 0 ;
23656 int arg2 = (int) 0 ;
23657 int arg3 = (int) 0 ;
23658 wxAcceleratorEntry *result;
23659 PyObject * obj0 = 0 ;
23660 PyObject * obj1 = 0 ;
23661 PyObject * obj2 = 0 ;
23662 char *kwnames[] = {
23663 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23664 };
23665
23666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23667 if (obj0) {
23668 {
23669 arg1 = (int)(SWIG_As_int(obj0));
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 }
23672 }
23673 if (obj1) {
23674 {
23675 arg2 = (int)(SWIG_As_int(obj1));
23676 if (SWIG_arg_fail(2)) SWIG_fail;
23677 }
23678 }
23679 if (obj2) {
23680 {
23681 arg3 = (int)(SWIG_As_int(obj2));
23682 if (SWIG_arg_fail(3)) SWIG_fail;
23683 }
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23688
23689 wxPyEndAllowThreads(__tstate);
23690 if (PyErr_Occurred()) SWIG_fail;
23691 }
23692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23702 PyObject * obj0 = 0 ;
23703 char *kwnames[] = {
23704 (char *) "self", NULL
23705 };
23706
23707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23709 if (SWIG_arg_fail(1)) SWIG_fail;
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 delete arg1;
23713
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 Py_INCREF(Py_None); resultobj = Py_None;
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj;
23726 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23727 int arg2 ;
23728 int arg3 ;
23729 int arg4 ;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 PyObject * obj2 = 0 ;
23733 PyObject * obj3 = 0 ;
23734 char *kwnames[] = {
23735 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23740 if (SWIG_arg_fail(1)) SWIG_fail;
23741 {
23742 arg2 = (int)(SWIG_As_int(obj1));
23743 if (SWIG_arg_fail(2)) SWIG_fail;
23744 }
23745 {
23746 arg3 = (int)(SWIG_As_int(obj2));
23747 if (SWIG_arg_fail(3)) SWIG_fail;
23748 }
23749 {
23750 arg4 = (int)(SWIG_As_int(obj3));
23751 if (SWIG_arg_fail(4)) SWIG_fail;
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 (arg1)->Set(arg2,arg3,arg4);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 Py_INCREF(Py_None); resultobj = Py_None;
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj;
23769 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23770 int result;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "self", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23778 if (SWIG_arg_fail(1)) SWIG_fail;
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (int)(arg1)->GetFlags();
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 resultobj = SWIG_From_int((int)(result));
23788 }
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23798 int result;
23799 PyObject * obj0 = 0 ;
23800 char *kwnames[] = {
23801 (char *) "self", NULL
23802 };
23803
23804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 result = (int)(arg1)->GetKeyCode();
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 {
23815 resultobj = SWIG_From_int((int)(result));
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj;
23825 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23826 int result;
23827 PyObject * obj0 = 0 ;
23828 char *kwnames[] = {
23829 (char *) "self", NULL
23830 };
23831
23832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23834 if (SWIG_arg_fail(1)) SWIG_fail;
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (int)(arg1)->GetCommand();
23838
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 {
23843 resultobj = SWIG_From_int((int)(result));
23844 }
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23852 PyObject *obj;
23853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23854 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23855 Py_INCREF(obj);
23856 return Py_BuildValue((char *)"");
23857 }
23858 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23859 PyObject *resultobj;
23860 int arg1 ;
23861 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23862 wxAcceleratorTable *result;
23863 PyObject * obj0 = 0 ;
23864 char *kwnames[] = {
23865 (char *) "n", NULL
23866 };
23867
23868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23869 {
23870 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23871 if (arg2) arg1 = PyList_Size(obj0);
23872 else arg1 = 0;
23873 }
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23882 {
23883 delete [] arg2;
23884 }
23885 return resultobj;
23886 fail:
23887 {
23888 delete [] arg2;
23889 }
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23897 PyObject * obj0 = 0 ;
23898 char *kwnames[] = {
23899 (char *) "self", NULL
23900 };
23901
23902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23904 if (SWIG_arg_fail(1)) SWIG_fail;
23905 {
23906 PyThreadState* __tstate = wxPyBeginAllowThreads();
23907 delete arg1;
23908
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 Py_INCREF(Py_None); resultobj = Py_None;
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23922 bool result;
23923 PyObject * obj0 = 0 ;
23924 char *kwnames[] = {
23925 (char *) "self", NULL
23926 };
23927
23928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23930 if (SWIG_arg_fail(1)) SWIG_fail;
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23934
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 {
23939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23940 }
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23948 PyObject *obj;
23949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23950 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23951 Py_INCREF(obj);
23952 return Py_BuildValue((char *)"");
23953 }
23954 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23955 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23956 return 1;
23957 }
23958
23959
23960 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23961 PyObject *pyobj;
23962
23963 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23964 return pyobj;
23965 }
23966
23967
23968 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj;
23970 wxString *arg1 = 0 ;
23971 wxAcceleratorEntry *result;
23972 bool temp1 = false ;
23973 PyObject * obj0 = 0 ;
23974 char *kwnames[] = {
23975 (char *) "label", NULL
23976 };
23977
23978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23979 {
23980 arg1 = wxString_in_helper(obj0);
23981 if (arg1 == NULL) SWIG_fail;
23982 temp1 = true;
23983 }
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23992 {
23993 if (temp1)
23994 delete arg1;
23995 }
23996 return resultobj;
23997 fail:
23998 {
23999 if (temp1)
24000 delete arg1;
24001 }
24002 return NULL;
24003 }
24004
24005
24006 static int _wrap_PanelNameStr_set(PyObject *) {
24007 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24008 return 1;
24009 }
24010
24011
24012 static PyObject *_wrap_PanelNameStr_get(void) {
24013 PyObject *pyobj;
24014
24015 {
24016 #if wxUSE_UNICODE
24017 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24018 #else
24019 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24020 #endif
24021 }
24022 return pyobj;
24023 }
24024
24025
24026 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24027 PyObject *resultobj;
24028 wxVisualAttributes *result;
24029 char *kwnames[] = {
24030 NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (wxVisualAttributes *)new_wxVisualAttributes();
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24051 PyObject * obj0 = 0 ;
24052 char *kwnames[] = {
24053 (char *) "self", NULL
24054 };
24055
24056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24058 if (SWIG_arg_fail(1)) SWIG_fail;
24059 {
24060 PyThreadState* __tstate = wxPyBeginAllowThreads();
24061 delete_wxVisualAttributes(arg1);
24062
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 Py_INCREF(Py_None); resultobj = Py_None;
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj;
24075 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24076 wxFont *arg2 = (wxFont *) 0 ;
24077 PyObject * obj0 = 0 ;
24078 PyObject * obj1 = 0 ;
24079 char *kwnames[] = {
24080 (char *) "self",(char *) "font", NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(1)) SWIG_fail;
24086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24087 if (SWIG_arg_fail(2)) SWIG_fail;
24088 if (arg1) (arg1)->font = *arg2;
24089
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24100 wxFont *result;
24101 PyObject * obj0 = 0 ;
24102 char *kwnames[] = {
24103 (char *) "self", NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24108 if (SWIG_arg_fail(1)) SWIG_fail;
24109 result = (wxFont *)& ((arg1)->font);
24110
24111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj;
24120 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24121 wxColour *arg2 = (wxColour *) 0 ;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self",(char *) "colFg", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 if (arg1) (arg1)->colFg = *arg2;
24134
24135 Py_INCREF(Py_None); resultobj = Py_None;
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24145 wxColour *result;
24146 PyObject * obj0 = 0 ;
24147 char *kwnames[] = {
24148 (char *) "self", NULL
24149 };
24150
24151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24153 if (SWIG_arg_fail(1)) SWIG_fail;
24154 result = (wxColour *)& ((arg1)->colFg);
24155
24156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj;
24165 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24166 wxColour *arg2 = (wxColour *) 0 ;
24167 PyObject * obj0 = 0 ;
24168 PyObject * obj1 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "self",(char *) "colBg", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(2)) SWIG_fail;
24178 if (arg1) (arg1)->colBg = *arg2;
24179
24180 Py_INCREF(Py_None); resultobj = Py_None;
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj;
24189 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24190 wxColour *result;
24191 PyObject * obj0 = 0 ;
24192 char *kwnames[] = {
24193 (char *) "self", NULL
24194 };
24195
24196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24198 if (SWIG_arg_fail(1)) SWIG_fail;
24199 result = (wxColour *)& ((arg1)->colBg);
24200
24201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24209 PyObject *obj;
24210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24211 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24212 Py_INCREF(obj);
24213 return Py_BuildValue((char *)"");
24214 }
24215 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24216 PyObject *resultobj;
24217 wxWindow *arg1 = (wxWindow *) 0 ;
24218 int arg2 = (int) (int)-1 ;
24219 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24220 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24221 wxSize const &arg4_defvalue = wxDefaultSize ;
24222 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24223 long arg5 = (long) 0 ;
24224 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24225 wxString *arg6 = (wxString *) &arg6_defvalue ;
24226 wxWindow *result;
24227 wxPoint temp3 ;
24228 wxSize temp4 ;
24229 bool temp6 = false ;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 PyObject * obj2 = 0 ;
24233 PyObject * obj3 = 0 ;
24234 PyObject * obj4 = 0 ;
24235 PyObject * obj5 = 0 ;
24236 char *kwnames[] = {
24237 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24238 };
24239
24240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 if (obj1) {
24244 {
24245 arg2 = (int const)(SWIG_As_int(obj1));
24246 if (SWIG_arg_fail(2)) SWIG_fail;
24247 }
24248 }
24249 if (obj2) {
24250 {
24251 arg3 = &temp3;
24252 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24253 }
24254 }
24255 if (obj3) {
24256 {
24257 arg4 = &temp4;
24258 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24259 }
24260 }
24261 if (obj4) {
24262 {
24263 arg5 = (long)(SWIG_As_long(obj4));
24264 if (SWIG_arg_fail(5)) SWIG_fail;
24265 }
24266 }
24267 if (obj5) {
24268 {
24269 arg6 = wxString_in_helper(obj5);
24270 if (arg6 == NULL) SWIG_fail;
24271 temp6 = true;
24272 }
24273 }
24274 {
24275 if (!wxPyCheckForApp()) SWIG_fail;
24276 PyThreadState* __tstate = wxPyBeginAllowThreads();
24277 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24278
24279 wxPyEndAllowThreads(__tstate);
24280 if (PyErr_Occurred()) SWIG_fail;
24281 }
24282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24283 {
24284 if (temp6)
24285 delete arg6;
24286 }
24287 return resultobj;
24288 fail:
24289 {
24290 if (temp6)
24291 delete arg6;
24292 }
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24298 PyObject *resultobj;
24299 wxWindow *result;
24300 char *kwnames[] = {
24301 NULL
24302 };
24303
24304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24305 {
24306 if (!wxPyCheckForApp()) SWIG_fail;
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 result = (wxWindow *)new wxWindow();
24309
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxWindow *arg1 = (wxWindow *) 0 ;
24323 wxWindow *arg2 = (wxWindow *) 0 ;
24324 int arg3 = (int) (int)-1 ;
24325 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24326 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24327 wxSize const &arg5_defvalue = wxDefaultSize ;
24328 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24329 long arg6 = (long) 0 ;
24330 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24331 wxString *arg7 = (wxString *) &arg7_defvalue ;
24332 bool result;
24333 wxPoint temp4 ;
24334 wxSize temp5 ;
24335 bool temp7 = false ;
24336 PyObject * obj0 = 0 ;
24337 PyObject * obj1 = 0 ;
24338 PyObject * obj2 = 0 ;
24339 PyObject * obj3 = 0 ;
24340 PyObject * obj4 = 0 ;
24341 PyObject * obj5 = 0 ;
24342 PyObject * obj6 = 0 ;
24343 char *kwnames[] = {
24344 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24345 };
24346
24347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24349 if (SWIG_arg_fail(1)) SWIG_fail;
24350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(2)) SWIG_fail;
24352 if (obj2) {
24353 {
24354 arg3 = (int const)(SWIG_As_int(obj2));
24355 if (SWIG_arg_fail(3)) SWIG_fail;
24356 }
24357 }
24358 if (obj3) {
24359 {
24360 arg4 = &temp4;
24361 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24362 }
24363 }
24364 if (obj4) {
24365 {
24366 arg5 = &temp5;
24367 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24368 }
24369 }
24370 if (obj5) {
24371 {
24372 arg6 = (long)(SWIG_As_long(obj5));
24373 if (SWIG_arg_fail(6)) SWIG_fail;
24374 }
24375 }
24376 if (obj6) {
24377 {
24378 arg7 = wxString_in_helper(obj6);
24379 if (arg7 == NULL) SWIG_fail;
24380 temp7 = true;
24381 }
24382 }
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 {
24391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24392 }
24393 {
24394 if (temp7)
24395 delete arg7;
24396 }
24397 return resultobj;
24398 fail:
24399 {
24400 if (temp7)
24401 delete arg7;
24402 }
24403 return NULL;
24404 }
24405
24406
24407 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj;
24409 wxWindow *arg1 = (wxWindow *) 0 ;
24410 bool arg2 = (bool) false ;
24411 bool result;
24412 PyObject * obj0 = 0 ;
24413 PyObject * obj1 = 0 ;
24414 char *kwnames[] = {
24415 (char *) "self",(char *) "force", NULL
24416 };
24417
24418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24420 if (SWIG_arg_fail(1)) SWIG_fail;
24421 if (obj1) {
24422 {
24423 arg2 = (bool)(SWIG_As_bool(obj1));
24424 if (SWIG_arg_fail(2)) SWIG_fail;
24425 }
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (bool)(arg1)->Close(arg2);
24430
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 {
24435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24436 }
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj;
24445 wxWindow *arg1 = (wxWindow *) 0 ;
24446 bool result;
24447 PyObject * obj0 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "self", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24454 if (SWIG_arg_fail(1)) SWIG_fail;
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (bool)(arg1)->Destroy();
24458
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 {
24463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24464 }
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj;
24473 wxWindow *arg1 = (wxWindow *) 0 ;
24474 bool result;
24475 PyObject * obj0 = 0 ;
24476 char *kwnames[] = {
24477 (char *) "self", NULL
24478 };
24479
24480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24482 if (SWIG_arg_fail(1)) SWIG_fail;
24483 {
24484 PyThreadState* __tstate = wxPyBeginAllowThreads();
24485 result = (bool)(arg1)->DestroyChildren();
24486
24487 wxPyEndAllowThreads(__tstate);
24488 if (PyErr_Occurred()) SWIG_fail;
24489 }
24490 {
24491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24492 }
24493 return resultobj;
24494 fail:
24495 return NULL;
24496 }
24497
24498
24499 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj;
24501 wxWindow *arg1 = (wxWindow *) 0 ;
24502 bool result;
24503 PyObject * obj0 = 0 ;
24504 char *kwnames[] = {
24505 (char *) "self", NULL
24506 };
24507
24508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24510 if (SWIG_arg_fail(1)) SWIG_fail;
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24514
24515 wxPyEndAllowThreads(__tstate);
24516 if (PyErr_Occurred()) SWIG_fail;
24517 }
24518 {
24519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24520 }
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24528 PyObject *resultobj;
24529 wxWindow *arg1 = (wxWindow *) 0 ;
24530 wxString *arg2 = 0 ;
24531 bool temp2 = false ;
24532 PyObject * obj0 = 0 ;
24533 PyObject * obj1 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "self",(char *) "title", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24540 if (SWIG_arg_fail(1)) SWIG_fail;
24541 {
24542 arg2 = wxString_in_helper(obj1);
24543 if (arg2 == NULL) SWIG_fail;
24544 temp2 = true;
24545 }
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 (arg1)->SetTitle((wxString const &)*arg2);
24549
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 Py_INCREF(Py_None); resultobj = Py_None;
24554 {
24555 if (temp2)
24556 delete arg2;
24557 }
24558 return resultobj;
24559 fail:
24560 {
24561 if (temp2)
24562 delete arg2;
24563 }
24564 return NULL;
24565 }
24566
24567
24568 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj;
24570 wxWindow *arg1 = (wxWindow *) 0 ;
24571 wxString result;
24572 PyObject * obj0 = 0 ;
24573 char *kwnames[] = {
24574 (char *) "self", NULL
24575 };
24576
24577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24579 if (SWIG_arg_fail(1)) SWIG_fail;
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 result = ((wxWindow const *)arg1)->GetTitle();
24583
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 {
24588 #if wxUSE_UNICODE
24589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24590 #else
24591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24592 #endif
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24601 PyObject *resultobj;
24602 wxWindow *arg1 = (wxWindow *) 0 ;
24603 wxString *arg2 = 0 ;
24604 bool temp2 = false ;
24605 PyObject * obj0 = 0 ;
24606 PyObject * obj1 = 0 ;
24607 char *kwnames[] = {
24608 (char *) "self",(char *) "label", NULL
24609 };
24610
24611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24613 if (SWIG_arg_fail(1)) SWIG_fail;
24614 {
24615 arg2 = wxString_in_helper(obj1);
24616 if (arg2 == NULL) SWIG_fail;
24617 temp2 = true;
24618 }
24619 {
24620 PyThreadState* __tstate = wxPyBeginAllowThreads();
24621 (arg1)->SetLabel((wxString const &)*arg2);
24622
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 Py_INCREF(Py_None); resultobj = Py_None;
24627 {
24628 if (temp2)
24629 delete arg2;
24630 }
24631 return resultobj;
24632 fail:
24633 {
24634 if (temp2)
24635 delete arg2;
24636 }
24637 return NULL;
24638 }
24639
24640
24641 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj;
24643 wxWindow *arg1 = (wxWindow *) 0 ;
24644 wxString result;
24645 PyObject * obj0 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = ((wxWindow const *)arg1)->GetLabel();
24656
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 {
24661 #if wxUSE_UNICODE
24662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24663 #else
24664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24665 #endif
24666 }
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24674 PyObject *resultobj;
24675 wxWindow *arg1 = (wxWindow *) 0 ;
24676 wxString *arg2 = 0 ;
24677 bool temp2 = false ;
24678 PyObject * obj0 = 0 ;
24679 PyObject * obj1 = 0 ;
24680 char *kwnames[] = {
24681 (char *) "self",(char *) "name", NULL
24682 };
24683
24684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24686 if (SWIG_arg_fail(1)) SWIG_fail;
24687 {
24688 arg2 = wxString_in_helper(obj1);
24689 if (arg2 == NULL) SWIG_fail;
24690 temp2 = true;
24691 }
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 (arg1)->SetName((wxString const &)*arg2);
24695
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 Py_INCREF(Py_None); resultobj = Py_None;
24700 {
24701 if (temp2)
24702 delete arg2;
24703 }
24704 return resultobj;
24705 fail:
24706 {
24707 if (temp2)
24708 delete arg2;
24709 }
24710 return NULL;
24711 }
24712
24713
24714 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj;
24716 wxWindow *arg1 = (wxWindow *) 0 ;
24717 wxString result;
24718 PyObject * obj0 = 0 ;
24719 char *kwnames[] = {
24720 (char *) "self", NULL
24721 };
24722
24723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24725 if (SWIG_arg_fail(1)) SWIG_fail;
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 result = ((wxWindow const *)arg1)->GetName();
24729
24730 wxPyEndAllowThreads(__tstate);
24731 if (PyErr_Occurred()) SWIG_fail;
24732 }
24733 {
24734 #if wxUSE_UNICODE
24735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24736 #else
24737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24738 #endif
24739 }
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj;
24748 wxWindow *arg1 = (wxWindow *) 0 ;
24749 wxWindowVariant arg2 ;
24750 PyObject * obj0 = 0 ;
24751 PyObject * obj1 = 0 ;
24752 char *kwnames[] = {
24753 (char *) "self",(char *) "variant", NULL
24754 };
24755
24756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24758 if (SWIG_arg_fail(1)) SWIG_fail;
24759 {
24760 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24761 if (SWIG_arg_fail(2)) SWIG_fail;
24762 }
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24766
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 Py_INCREF(Py_None); resultobj = Py_None;
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24778 PyObject *resultobj;
24779 wxWindow *arg1 = (wxWindow *) 0 ;
24780 wxWindowVariant result;
24781 PyObject * obj0 = 0 ;
24782 char *kwnames[] = {
24783 (char *) "self", NULL
24784 };
24785
24786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24788 if (SWIG_arg_fail(1)) SWIG_fail;
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24792
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_From_int((result));
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj;
24805 wxWindow *arg1 = (wxWindow *) 0 ;
24806 int arg2 ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self",(char *) "winid", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 {
24817 arg2 = (int)(SWIG_As_int(obj1));
24818 if (SWIG_arg_fail(2)) SWIG_fail;
24819 }
24820 {
24821 PyThreadState* __tstate = wxPyBeginAllowThreads();
24822 (arg1)->SetId(arg2);
24823
24824 wxPyEndAllowThreads(__tstate);
24825 if (PyErr_Occurred()) SWIG_fail;
24826 }
24827 Py_INCREF(Py_None); resultobj = Py_None;
24828 return resultobj;
24829 fail:
24830 return NULL;
24831 }
24832
24833
24834 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24835 PyObject *resultobj;
24836 wxWindow *arg1 = (wxWindow *) 0 ;
24837 int result;
24838 PyObject * obj0 = 0 ;
24839 char *kwnames[] = {
24840 (char *) "self", NULL
24841 };
24842
24843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24845 if (SWIG_arg_fail(1)) SWIG_fail;
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (int)((wxWindow const *)arg1)->GetId();
24849
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 resultobj = SWIG_From_int((int)(result));
24855 }
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24863 PyObject *resultobj;
24864 int result;
24865 char *kwnames[] = {
24866 NULL
24867 };
24868
24869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 result = (int)wxWindow::NewControlId();
24873
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 resultobj = SWIG_From_int((int)(result));
24879 }
24880 return resultobj;
24881 fail:
24882 return NULL;
24883 }
24884
24885
24886 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24887 PyObject *resultobj;
24888 int arg1 ;
24889 int result;
24890 PyObject * obj0 = 0 ;
24891 char *kwnames[] = {
24892 (char *) "winid", NULL
24893 };
24894
24895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24896 {
24897 arg1 = (int)(SWIG_As_int(obj0));
24898 if (SWIG_arg_fail(1)) SWIG_fail;
24899 }
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (int)wxWindow::NextControlId(arg1);
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 resultobj = SWIG_From_int((int)(result));
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 int arg1 ;
24919 int result;
24920 PyObject * obj0 = 0 ;
24921 char *kwnames[] = {
24922 (char *) "winid", NULL
24923 };
24924
24925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24926 {
24927 arg1 = (int)(SWIG_As_int(obj0));
24928 if (SWIG_arg_fail(1)) SWIG_fail;
24929 }
24930 {
24931 PyThreadState* __tstate = wxPyBeginAllowThreads();
24932 result = (int)wxWindow::PrevControlId(arg1);
24933
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 {
24938 resultobj = SWIG_From_int((int)(result));
24939 }
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj;
24948 wxWindow *arg1 = (wxWindow *) 0 ;
24949 wxSize *arg2 = 0 ;
24950 wxSize temp2 ;
24951 PyObject * obj0 = 0 ;
24952 PyObject * obj1 = 0 ;
24953 char *kwnames[] = {
24954 (char *) "self",(char *) "size", NULL
24955 };
24956
24957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24959 if (SWIG_arg_fail(1)) SWIG_fail;
24960 {
24961 arg2 = &temp2;
24962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24963 }
24964 {
24965 PyThreadState* __tstate = wxPyBeginAllowThreads();
24966 (arg1)->SetSize((wxSize const &)*arg2);
24967
24968 wxPyEndAllowThreads(__tstate);
24969 if (PyErr_Occurred()) SWIG_fail;
24970 }
24971 Py_INCREF(Py_None); resultobj = Py_None;
24972 return resultobj;
24973 fail:
24974 return NULL;
24975 }
24976
24977
24978 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24979 PyObject *resultobj;
24980 wxWindow *arg1 = (wxWindow *) 0 ;
24981 int arg2 ;
24982 int arg3 ;
24983 int arg4 ;
24984 int arg5 ;
24985 int arg6 = (int) wxSIZE_AUTO ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 PyObject * obj2 = 0 ;
24989 PyObject * obj3 = 0 ;
24990 PyObject * obj4 = 0 ;
24991 PyObject * obj5 = 0 ;
24992 char *kwnames[] = {
24993 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24994 };
24995
24996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24998 if (SWIG_arg_fail(1)) SWIG_fail;
24999 {
25000 arg2 = (int)(SWIG_As_int(obj1));
25001 if (SWIG_arg_fail(2)) SWIG_fail;
25002 }
25003 {
25004 arg3 = (int)(SWIG_As_int(obj2));
25005 if (SWIG_arg_fail(3)) SWIG_fail;
25006 }
25007 {
25008 arg4 = (int)(SWIG_As_int(obj3));
25009 if (SWIG_arg_fail(4)) SWIG_fail;
25010 }
25011 {
25012 arg5 = (int)(SWIG_As_int(obj4));
25013 if (SWIG_arg_fail(5)) SWIG_fail;
25014 }
25015 if (obj5) {
25016 {
25017 arg6 = (int)(SWIG_As_int(obj5));
25018 if (SWIG_arg_fail(6)) SWIG_fail;
25019 }
25020 }
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 Py_INCREF(Py_None); resultobj = Py_None;
25029 return resultobj;
25030 fail:
25031 return NULL;
25032 }
25033
25034
25035 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25036 PyObject *resultobj;
25037 wxWindow *arg1 = (wxWindow *) 0 ;
25038 wxRect *arg2 = 0 ;
25039 int arg3 = (int) wxSIZE_AUTO ;
25040 wxRect temp2 ;
25041 PyObject * obj0 = 0 ;
25042 PyObject * obj1 = 0 ;
25043 PyObject * obj2 = 0 ;
25044 char *kwnames[] = {
25045 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25046 };
25047
25048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25050 if (SWIG_arg_fail(1)) SWIG_fail;
25051 {
25052 arg2 = &temp2;
25053 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25054 }
25055 if (obj2) {
25056 {
25057 arg3 = (int)(SWIG_As_int(obj2));
25058 if (SWIG_arg_fail(3)) SWIG_fail;
25059 }
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 Py_INCREF(Py_None); resultobj = Py_None;
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj;
25077 wxWindow *arg1 = (wxWindow *) 0 ;
25078 int arg2 ;
25079 int arg3 ;
25080 PyObject * obj0 = 0 ;
25081 PyObject * obj1 = 0 ;
25082 PyObject * obj2 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self",(char *) "width",(char *) "height", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 arg2 = (int)(SWIG_As_int(obj1));
25092 if (SWIG_arg_fail(2)) SWIG_fail;
25093 }
25094 {
25095 arg3 = (int)(SWIG_As_int(obj2));
25096 if (SWIG_arg_fail(3)) SWIG_fail;
25097 }
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 (arg1)->SetSize(arg2,arg3);
25101
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 Py_INCREF(Py_None); resultobj = Py_None;
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 wxPoint *arg2 = 0 ;
25116 int arg3 = (int) wxSIZE_USE_EXISTING ;
25117 wxPoint temp2 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 PyObject * obj2 = 0 ;
25121 char *kwnames[] = {
25122 (char *) "self",(char *) "pt",(char *) "flags", NULL
25123 };
25124
25125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25127 if (SWIG_arg_fail(1)) SWIG_fail;
25128 {
25129 arg2 = &temp2;
25130 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25131 }
25132 if (obj2) {
25133 {
25134 arg3 = (int)(SWIG_As_int(obj2));
25135 if (SWIG_arg_fail(3)) SWIG_fail;
25136 }
25137 }
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 (arg1)->Move((wxPoint const &)*arg2,arg3);
25141
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 Py_INCREF(Py_None); resultobj = Py_None;
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 wxWindow *arg1 = (wxWindow *) 0 ;
25155 int arg2 ;
25156 int arg3 ;
25157 int arg4 = (int) wxSIZE_USE_EXISTING ;
25158 PyObject * obj0 = 0 ;
25159 PyObject * obj1 = 0 ;
25160 PyObject * obj2 = 0 ;
25161 PyObject * obj3 = 0 ;
25162 char *kwnames[] = {
25163 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25164 };
25165
25166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25168 if (SWIG_arg_fail(1)) SWIG_fail;
25169 {
25170 arg2 = (int)(SWIG_As_int(obj1));
25171 if (SWIG_arg_fail(2)) SWIG_fail;
25172 }
25173 {
25174 arg3 = (int)(SWIG_As_int(obj2));
25175 if (SWIG_arg_fail(3)) SWIG_fail;
25176 }
25177 if (obj3) {
25178 {
25179 arg4 = (int)(SWIG_As_int(obj3));
25180 if (SWIG_arg_fail(4)) SWIG_fail;
25181 }
25182 }
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 (arg1)->Move(arg2,arg3,arg4);
25186
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 Py_INCREF(Py_None); resultobj = Py_None;
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25198 PyObject *resultobj;
25199 wxWindow *arg1 = (wxWindow *) 0 ;
25200 wxSize const &arg2_defvalue = wxDefaultSize ;
25201 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25202 wxSize temp2 ;
25203 PyObject * obj0 = 0 ;
25204 PyObject * obj1 = 0 ;
25205 char *kwnames[] = {
25206 (char *) "self",(char *) "size", NULL
25207 };
25208
25209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25211 if (SWIG_arg_fail(1)) SWIG_fail;
25212 if (obj1) {
25213 {
25214 arg2 = &temp2;
25215 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25216 }
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 Py_INCREF(Py_None); resultobj = Py_None;
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25233 PyObject *resultobj;
25234 wxWindow *arg1 = (wxWindow *) 0 ;
25235 PyObject * obj0 = 0 ;
25236 char *kwnames[] = {
25237 (char *) "self", NULL
25238 };
25239
25240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25242 if (SWIG_arg_fail(1)) SWIG_fail;
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 (arg1)->Raise();
25246
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 Py_INCREF(Py_None); resultobj = Py_None;
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj;
25259 wxWindow *arg1 = (wxWindow *) 0 ;
25260 PyObject * obj0 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "self", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 (arg1)->Lower();
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_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj;
25284 wxWindow *arg1 = (wxWindow *) 0 ;
25285 wxSize *arg2 = 0 ;
25286 wxSize temp2 ;
25287 PyObject * obj0 = 0 ;
25288 PyObject * obj1 = 0 ;
25289 char *kwnames[] = {
25290 (char *) "self",(char *) "size", NULL
25291 };
25292
25293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25295 if (SWIG_arg_fail(1)) SWIG_fail;
25296 {
25297 arg2 = &temp2;
25298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25299 }
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 (arg1)->SetClientSize((wxSize const &)*arg2);
25303
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 Py_INCREF(Py_None); resultobj = Py_None;
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj;
25316 wxWindow *arg1 = (wxWindow *) 0 ;
25317 int arg2 ;
25318 int arg3 ;
25319 PyObject * obj0 = 0 ;
25320 PyObject * obj1 = 0 ;
25321 PyObject * obj2 = 0 ;
25322 char *kwnames[] = {
25323 (char *) "self",(char *) "width",(char *) "height", NULL
25324 };
25325
25326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25328 if (SWIG_arg_fail(1)) SWIG_fail;
25329 {
25330 arg2 = (int)(SWIG_As_int(obj1));
25331 if (SWIG_arg_fail(2)) SWIG_fail;
25332 }
25333 {
25334 arg3 = (int)(SWIG_As_int(obj2));
25335 if (SWIG_arg_fail(3)) SWIG_fail;
25336 }
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 (arg1)->SetClientSize(arg2,arg3);
25340
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 Py_INCREF(Py_None); resultobj = Py_None;
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25352 PyObject *resultobj;
25353 wxWindow *arg1 = (wxWindow *) 0 ;
25354 wxRect *arg2 = 0 ;
25355 wxRect temp2 ;
25356 PyObject * obj0 = 0 ;
25357 PyObject * obj1 = 0 ;
25358 char *kwnames[] = {
25359 (char *) "self",(char *) "rect", NULL
25360 };
25361
25362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25364 if (SWIG_arg_fail(1)) SWIG_fail;
25365 {
25366 arg2 = &temp2;
25367 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25368 }
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->SetClientSize((wxRect const &)*arg2);
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 Py_INCREF(Py_None); resultobj = Py_None;
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 wxWindow *arg1 = (wxWindow *) 0 ;
25386 wxPoint result;
25387 PyObject * obj0 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 PyThreadState* __tstate = wxPyBeginAllowThreads();
25397 result = (arg1)->GetPosition();
25398
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 {
25403 wxPoint * resultptr;
25404 resultptr = new wxPoint((wxPoint &)(result));
25405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 wxWindow *arg1 = (wxWindow *) 0 ;
25416 int *arg2 = (int *) 0 ;
25417 int *arg3 = (int *) 0 ;
25418 int temp2 ;
25419 int res2 = 0 ;
25420 int temp3 ;
25421 int res3 = 0 ;
25422 PyObject * obj0 = 0 ;
25423 char *kwnames[] = {
25424 (char *) "self", NULL
25425 };
25426
25427 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25428 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25431 if (SWIG_arg_fail(1)) SWIG_fail;
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 (arg1)->GetPosition(arg2,arg3);
25435
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 Py_INCREF(Py_None); resultobj = Py_None;
25440 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25441 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25442 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25443 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj;
25452 wxWindow *arg1 = (wxWindow *) 0 ;
25453 wxSize result;
25454 PyObject * obj0 = 0 ;
25455 char *kwnames[] = {
25456 (char *) "self", NULL
25457 };
25458
25459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25461 if (SWIG_arg_fail(1)) SWIG_fail;
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 result = ((wxWindow const *)arg1)->GetSize();
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 {
25470 wxSize * resultptr;
25471 resultptr = new wxSize((wxSize &)(result));
25472 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25473 }
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj;
25482 wxWindow *arg1 = (wxWindow *) 0 ;
25483 int *arg2 = (int *) 0 ;
25484 int *arg3 = (int *) 0 ;
25485 int temp2 ;
25486 int res2 = 0 ;
25487 int temp3 ;
25488 int res3 = 0 ;
25489 PyObject * obj0 = 0 ;
25490 char *kwnames[] = {
25491 (char *) "self", NULL
25492 };
25493
25494 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25495 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25498 if (SWIG_arg_fail(1)) SWIG_fail;
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25502
25503 wxPyEndAllowThreads(__tstate);
25504 if (PyErr_Occurred()) SWIG_fail;
25505 }
25506 Py_INCREF(Py_None); resultobj = Py_None;
25507 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25508 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25509 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25510 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj;
25519 wxWindow *arg1 = (wxWindow *) 0 ;
25520 wxRect result;
25521 PyObject * obj0 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "self", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 result = ((wxWindow const *)arg1)->GetRect();
25532
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 {
25537 wxRect * resultptr;
25538 resultptr = new wxRect((wxRect &)(result));
25539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25540 }
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj;
25549 wxWindow *arg1 = (wxWindow *) 0 ;
25550 wxSize result;
25551 PyObject * obj0 = 0 ;
25552 char *kwnames[] = {
25553 (char *) "self", NULL
25554 };
25555
25556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25558 if (SWIG_arg_fail(1)) SWIG_fail;
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = ((wxWindow const *)arg1)->GetClientSize();
25562
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 {
25567 wxSize * resultptr;
25568 resultptr = new wxSize((wxSize &)(result));
25569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25570 }
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 wxWindow *arg1 = (wxWindow *) 0 ;
25580 int *arg2 = (int *) 0 ;
25581 int *arg3 = (int *) 0 ;
25582 int temp2 ;
25583 int res2 = 0 ;
25584 int temp3 ;
25585 int res3 = 0 ;
25586 PyObject * obj0 = 0 ;
25587 char *kwnames[] = {
25588 (char *) "self", NULL
25589 };
25590
25591 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25595 if (SWIG_arg_fail(1)) SWIG_fail;
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25599
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 Py_INCREF(Py_None); resultobj = Py_None;
25604 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25605 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25606 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25607 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25608 return resultobj;
25609 fail:
25610 return NULL;
25611 }
25612
25613
25614 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25615 PyObject *resultobj;
25616 wxWindow *arg1 = (wxWindow *) 0 ;
25617 wxPoint result;
25618 PyObject * obj0 = 0 ;
25619 char *kwnames[] = {
25620 (char *) "self", NULL
25621 };
25622
25623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25625 if (SWIG_arg_fail(1)) SWIG_fail;
25626 {
25627 PyThreadState* __tstate = wxPyBeginAllowThreads();
25628 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 {
25634 wxPoint * resultptr;
25635 resultptr = new wxPoint((wxPoint &)(result));
25636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25637 }
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25645 PyObject *resultobj;
25646 wxWindow *arg1 = (wxWindow *) 0 ;
25647 wxRect result;
25648 PyObject * obj0 = 0 ;
25649 char *kwnames[] = {
25650 (char *) "self", NULL
25651 };
25652
25653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25655 if (SWIG_arg_fail(1)) SWIG_fail;
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 result = ((wxWindow const *)arg1)->GetClientRect();
25659
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 {
25664 wxRect * resultptr;
25665 resultptr = new wxRect((wxRect &)(result));
25666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25667 }
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj;
25676 wxWindow *arg1 = (wxWindow *) 0 ;
25677 wxSize result;
25678 PyObject * obj0 = 0 ;
25679 char *kwnames[] = {
25680 (char *) "self", NULL
25681 };
25682
25683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = ((wxWindow const *)arg1)->GetBestSize();
25689
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 {
25694 wxSize * resultptr;
25695 resultptr = new wxSize((wxSize &)(result));
25696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj;
25706 wxWindow *arg1 = (wxWindow *) 0 ;
25707 int *arg2 = (int *) 0 ;
25708 int *arg3 = (int *) 0 ;
25709 int temp2 ;
25710 int res2 = 0 ;
25711 int temp3 ;
25712 int res3 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 char *kwnames[] = {
25715 (char *) "self", NULL
25716 };
25717
25718 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25719 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(1)) SWIG_fail;
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25726
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 Py_INCREF(Py_None); resultobj = Py_None;
25731 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25732 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25733 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25734 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj;
25743 wxWindow *arg1 = (wxWindow *) 0 ;
25744 PyObject * obj0 = 0 ;
25745 char *kwnames[] = {
25746 (char *) "self", NULL
25747 };
25748
25749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25751 if (SWIG_arg_fail(1)) SWIG_fail;
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 (arg1)->InvalidateBestSize();
25755
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 Py_INCREF(Py_None); resultobj = Py_None;
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj;
25768 wxWindow *arg1 = (wxWindow *) 0 ;
25769 wxSize result;
25770 PyObject * obj0 = 0 ;
25771 char *kwnames[] = {
25772 (char *) "self", NULL
25773 };
25774
25775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25777 if (SWIG_arg_fail(1)) SWIG_fail;
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 {
25786 wxSize * resultptr;
25787 resultptr = new wxSize((wxSize &)(result));
25788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25797 PyObject *resultobj;
25798 wxWindow *arg1 = (wxWindow *) 0 ;
25799 wxSize result;
25800 PyObject * obj0 = 0 ;
25801 char *kwnames[] = {
25802 (char *) "self", NULL
25803 };
25804
25805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25807 if (SWIG_arg_fail(1)) SWIG_fail;
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25811
25812 wxPyEndAllowThreads(__tstate);
25813 if (PyErr_Occurred()) SWIG_fail;
25814 }
25815 {
25816 wxSize * resultptr;
25817 resultptr = new wxSize((wxSize &)(result));
25818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25819 }
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj;
25828 wxWindow *arg1 = (wxWindow *) 0 ;
25829 int arg2 = (int) wxBOTH ;
25830 PyObject * obj0 = 0 ;
25831 PyObject * obj1 = 0 ;
25832 char *kwnames[] = {
25833 (char *) "self",(char *) "direction", NULL
25834 };
25835
25836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
25837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25838 if (SWIG_arg_fail(1)) SWIG_fail;
25839 if (obj1) {
25840 {
25841 arg2 = (int)(SWIG_As_int(obj1));
25842 if (SWIG_arg_fail(2)) SWIG_fail;
25843 }
25844 }
25845 {
25846 PyThreadState* __tstate = wxPyBeginAllowThreads();
25847 (arg1)->Center(arg2);
25848
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 Py_INCREF(Py_None); resultobj = Py_None;
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj;
25861 wxWindow *arg1 = (wxWindow *) 0 ;
25862 int arg2 = (int) wxBOTH ;
25863 PyObject * obj0 = 0 ;
25864 PyObject * obj1 = 0 ;
25865 char *kwnames[] = {
25866 (char *) "self",(char *) "dir", NULL
25867 };
25868
25869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25871 if (SWIG_arg_fail(1)) SWIG_fail;
25872 if (obj1) {
25873 {
25874 arg2 = (int)(SWIG_As_int(obj1));
25875 if (SWIG_arg_fail(2)) SWIG_fail;
25876 }
25877 }
25878 {
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 (arg1)->CenterOnScreen(arg2);
25881
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 Py_INCREF(Py_None); resultobj = Py_None;
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25893 PyObject *resultobj;
25894 wxWindow *arg1 = (wxWindow *) 0 ;
25895 int arg2 = (int) wxBOTH ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self",(char *) "dir", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 if (obj1) {
25906 {
25907 arg2 = (int)(SWIG_As_int(obj1));
25908 if (SWIG_arg_fail(2)) SWIG_fail;
25909 }
25910 }
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 (arg1)->CenterOnParent(arg2);
25914
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 Py_INCREF(Py_None); resultobj = Py_None;
25919 return resultobj;
25920 fail:
25921 return NULL;
25922 }
25923
25924
25925 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj;
25927 wxWindow *arg1 = (wxWindow *) 0 ;
25928 PyObject * obj0 = 0 ;
25929 char *kwnames[] = {
25930 (char *) "self", NULL
25931 };
25932
25933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25935 if (SWIG_arg_fail(1)) SWIG_fail;
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 (arg1)->Fit();
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 Py_INCREF(Py_None); resultobj = Py_None;
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 wxWindow *arg1 = (wxWindow *) 0 ;
25953 PyObject * obj0 = 0 ;
25954 char *kwnames[] = {
25955 (char *) "self", NULL
25956 };
25957
25958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25960 if (SWIG_arg_fail(1)) SWIG_fail;
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 (arg1)->FitInside();
25964
25965 wxPyEndAllowThreads(__tstate);
25966 if (PyErr_Occurred()) SWIG_fail;
25967 }
25968 Py_INCREF(Py_None); resultobj = Py_None;
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25976 PyObject *resultobj;
25977 wxWindow *arg1 = (wxWindow *) 0 ;
25978 int arg2 ;
25979 int arg3 ;
25980 int arg4 = (int) -1 ;
25981 int arg5 = (int) -1 ;
25982 int arg6 = (int) -1 ;
25983 int arg7 = (int) -1 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 PyObject * obj2 = 0 ;
25987 PyObject * obj3 = 0 ;
25988 PyObject * obj4 = 0 ;
25989 PyObject * obj5 = 0 ;
25990 PyObject * obj6 = 0 ;
25991 char *kwnames[] = {
25992 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25993 };
25994
25995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25997 if (SWIG_arg_fail(1)) SWIG_fail;
25998 {
25999 arg2 = (int)(SWIG_As_int(obj1));
26000 if (SWIG_arg_fail(2)) SWIG_fail;
26001 }
26002 {
26003 arg3 = (int)(SWIG_As_int(obj2));
26004 if (SWIG_arg_fail(3)) SWIG_fail;
26005 }
26006 if (obj3) {
26007 {
26008 arg4 = (int)(SWIG_As_int(obj3));
26009 if (SWIG_arg_fail(4)) SWIG_fail;
26010 }
26011 }
26012 if (obj4) {
26013 {
26014 arg5 = (int)(SWIG_As_int(obj4));
26015 if (SWIG_arg_fail(5)) SWIG_fail;
26016 }
26017 }
26018 if (obj5) {
26019 {
26020 arg6 = (int)(SWIG_As_int(obj5));
26021 if (SWIG_arg_fail(6)) SWIG_fail;
26022 }
26023 }
26024 if (obj6) {
26025 {
26026 arg7 = (int)(SWIG_As_int(obj6));
26027 if (SWIG_arg_fail(7)) SWIG_fail;
26028 }
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 Py_INCREF(Py_None); resultobj = Py_None;
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj;
26046 wxWindow *arg1 = (wxWindow *) 0 ;
26047 wxSize *arg2 = 0 ;
26048 wxSize const &arg3_defvalue = wxDefaultSize ;
26049 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26050 wxSize const &arg4_defvalue = wxDefaultSize ;
26051 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26052 wxSize temp2 ;
26053 wxSize temp3 ;
26054 wxSize temp4 ;
26055 PyObject * obj0 = 0 ;
26056 PyObject * obj1 = 0 ;
26057 PyObject * obj2 = 0 ;
26058 PyObject * obj3 = 0 ;
26059 char *kwnames[] = {
26060 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26061 };
26062
26063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26065 if (SWIG_arg_fail(1)) SWIG_fail;
26066 {
26067 arg2 = &temp2;
26068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26069 }
26070 if (obj2) {
26071 {
26072 arg3 = &temp3;
26073 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26074 }
26075 }
26076 if (obj3) {
26077 {
26078 arg4 = &temp4;
26079 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26080 }
26081 }
26082 {
26083 PyThreadState* __tstate = wxPyBeginAllowThreads();
26084 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26085
26086 wxPyEndAllowThreads(__tstate);
26087 if (PyErr_Occurred()) SWIG_fail;
26088 }
26089 Py_INCREF(Py_None); resultobj = Py_None;
26090 return resultobj;
26091 fail:
26092 return NULL;
26093 }
26094
26095
26096 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26097 PyObject *resultobj;
26098 wxWindow *arg1 = (wxWindow *) 0 ;
26099 int arg2 ;
26100 int arg3 ;
26101 int arg4 = (int) -1 ;
26102 int arg5 = (int) -1 ;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 PyObject * obj2 = 0 ;
26106 PyObject * obj3 = 0 ;
26107 PyObject * obj4 = 0 ;
26108 char *kwnames[] = {
26109 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26110 };
26111
26112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26114 if (SWIG_arg_fail(1)) SWIG_fail;
26115 {
26116 arg2 = (int)(SWIG_As_int(obj1));
26117 if (SWIG_arg_fail(2)) SWIG_fail;
26118 }
26119 {
26120 arg3 = (int)(SWIG_As_int(obj2));
26121 if (SWIG_arg_fail(3)) SWIG_fail;
26122 }
26123 if (obj3) {
26124 {
26125 arg4 = (int)(SWIG_As_int(obj3));
26126 if (SWIG_arg_fail(4)) SWIG_fail;
26127 }
26128 }
26129 if (obj4) {
26130 {
26131 arg5 = (int)(SWIG_As_int(obj4));
26132 if (SWIG_arg_fail(5)) SWIG_fail;
26133 }
26134 }
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 Py_INCREF(Py_None); resultobj = Py_None;
26143 return resultobj;
26144 fail:
26145 return NULL;
26146 }
26147
26148
26149 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26150 PyObject *resultobj;
26151 wxWindow *arg1 = (wxWindow *) 0 ;
26152 wxSize *arg2 = 0 ;
26153 wxSize const &arg3_defvalue = wxDefaultSize ;
26154 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26155 wxSize temp2 ;
26156 wxSize temp3 ;
26157 PyObject * obj0 = 0 ;
26158 PyObject * obj1 = 0 ;
26159 PyObject * obj2 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 arg2 = &temp2;
26169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26170 }
26171 if (obj2) {
26172 {
26173 arg3 = &temp3;
26174 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26175 }
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26180
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 Py_INCREF(Py_None); resultobj = Py_None;
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj;
26193 wxWindow *arg1 = (wxWindow *) 0 ;
26194 wxSize result;
26195 PyObject * obj0 = 0 ;
26196 char *kwnames[] = {
26197 (char *) "self", NULL
26198 };
26199
26200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26202 if (SWIG_arg_fail(1)) SWIG_fail;
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 result = ((wxWindow const *)arg1)->GetMaxSize();
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 {
26211 wxSize * resultptr;
26212 resultptr = new wxSize((wxSize &)(result));
26213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj;
26223 wxWindow *arg1 = (wxWindow *) 0 ;
26224 wxSize result;
26225 PyObject * obj0 = 0 ;
26226 char *kwnames[] = {
26227 (char *) "self", NULL
26228 };
26229
26230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26232 if (SWIG_arg_fail(1)) SWIG_fail;
26233 {
26234 PyThreadState* __tstate = wxPyBeginAllowThreads();
26235 result = ((wxWindow const *)arg1)->GetMinSize();
26236
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 {
26241 wxSize * resultptr;
26242 resultptr = new wxSize((wxSize &)(result));
26243 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26244 }
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26252 PyObject *resultobj;
26253 wxWindow *arg1 = (wxWindow *) 0 ;
26254 wxSize *arg2 = 0 ;
26255 wxSize temp2 ;
26256 PyObject * obj0 = 0 ;
26257 PyObject * obj1 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self",(char *) "minSize", NULL
26260 };
26261
26262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26264 if (SWIG_arg_fail(1)) SWIG_fail;
26265 {
26266 arg2 = &temp2;
26267 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26268 }
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 (arg1)->SetMinSize((wxSize const &)*arg2);
26272
26273 wxPyEndAllowThreads(__tstate);
26274 if (PyErr_Occurred()) SWIG_fail;
26275 }
26276 Py_INCREF(Py_None); resultobj = Py_None;
26277 return resultobj;
26278 fail:
26279 return NULL;
26280 }
26281
26282
26283 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26284 PyObject *resultobj;
26285 wxWindow *arg1 = (wxWindow *) 0 ;
26286 wxSize *arg2 = 0 ;
26287 wxSize temp2 ;
26288 PyObject * obj0 = 0 ;
26289 PyObject * obj1 = 0 ;
26290 char *kwnames[] = {
26291 (char *) "self",(char *) "maxSize", NULL
26292 };
26293
26294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26296 if (SWIG_arg_fail(1)) SWIG_fail;
26297 {
26298 arg2 = &temp2;
26299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26300 }
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 (arg1)->SetMaxSize((wxSize const &)*arg2);
26304
26305 wxPyEndAllowThreads(__tstate);
26306 if (PyErr_Occurred()) SWIG_fail;
26307 }
26308 Py_INCREF(Py_None); resultobj = Py_None;
26309 return resultobj;
26310 fail:
26311 return NULL;
26312 }
26313
26314
26315 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26316 PyObject *resultobj;
26317 wxWindow *arg1 = (wxWindow *) 0 ;
26318 int result;
26319 PyObject * obj0 = 0 ;
26320 char *kwnames[] = {
26321 (char *) "self", NULL
26322 };
26323
26324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 resultobj = SWIG_From_int((int)(result));
26336 }
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 wxWindow *arg1 = (wxWindow *) 0 ;
26346 int result;
26347 PyObject * obj0 = 0 ;
26348 char *kwnames[] = {
26349 (char *) "self", NULL
26350 };
26351
26352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26354 if (SWIG_arg_fail(1)) SWIG_fail;
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26358
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 {
26363 resultobj = SWIG_From_int((int)(result));
26364 }
26365 return resultobj;
26366 fail:
26367 return NULL;
26368 }
26369
26370
26371 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26372 PyObject *resultobj;
26373 wxWindow *arg1 = (wxWindow *) 0 ;
26374 int result;
26375 PyObject * obj0 = 0 ;
26376 char *kwnames[] = {
26377 (char *) "self", NULL
26378 };
26379
26380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26382 if (SWIG_arg_fail(1)) SWIG_fail;
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 {
26391 resultobj = SWIG_From_int((int)(result));
26392 }
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26400 PyObject *resultobj;
26401 wxWindow *arg1 = (wxWindow *) 0 ;
26402 int result;
26403 PyObject * obj0 = 0 ;
26404 char *kwnames[] = {
26405 (char *) "self", NULL
26406 };
26407
26408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26410 if (SWIG_arg_fail(1)) SWIG_fail;
26411 {
26412 PyThreadState* __tstate = wxPyBeginAllowThreads();
26413 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26414
26415 wxPyEndAllowThreads(__tstate);
26416 if (PyErr_Occurred()) SWIG_fail;
26417 }
26418 {
26419 resultobj = SWIG_From_int((int)(result));
26420 }
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj;
26429 wxWindow *arg1 = (wxWindow *) 0 ;
26430 wxSize *arg2 = 0 ;
26431 wxSize temp2 ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char *kwnames[] = {
26435 (char *) "self",(char *) "size", NULL
26436 };
26437
26438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26440 if (SWIG_arg_fail(1)) SWIG_fail;
26441 {
26442 arg2 = &temp2;
26443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26444 }
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26448
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 Py_INCREF(Py_None); resultobj = Py_None;
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj;
26461 wxWindow *arg1 = (wxWindow *) 0 ;
26462 int arg2 ;
26463 int arg3 ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 PyObject * obj2 = 0 ;
26467 char *kwnames[] = {
26468 (char *) "self",(char *) "w",(char *) "h", NULL
26469 };
26470
26471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26473 if (SWIG_arg_fail(1)) SWIG_fail;
26474 {
26475 arg2 = (int)(SWIG_As_int(obj1));
26476 if (SWIG_arg_fail(2)) SWIG_fail;
26477 }
26478 {
26479 arg3 = (int)(SWIG_As_int(obj2));
26480 if (SWIG_arg_fail(3)) SWIG_fail;
26481 }
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 (arg1)->SetVirtualSize(arg2,arg3);
26485
26486 wxPyEndAllowThreads(__tstate);
26487 if (PyErr_Occurred()) SWIG_fail;
26488 }
26489 Py_INCREF(Py_None); resultobj = Py_None;
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26497 PyObject *resultobj;
26498 wxWindow *arg1 = (wxWindow *) 0 ;
26499 wxSize result;
26500 PyObject * obj0 = 0 ;
26501 char *kwnames[] = {
26502 (char *) "self", NULL
26503 };
26504
26505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26507 if (SWIG_arg_fail(1)) SWIG_fail;
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = ((wxWindow const *)arg1)->GetVirtualSize();
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 {
26516 wxSize * resultptr;
26517 resultptr = new wxSize((wxSize &)(result));
26518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26519 }
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj;
26528 wxWindow *arg1 = (wxWindow *) 0 ;
26529 int *arg2 = (int *) 0 ;
26530 int *arg3 = (int *) 0 ;
26531 int temp2 ;
26532 int res2 = 0 ;
26533 int temp3 ;
26534 int res3 = 0 ;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "self", NULL
26538 };
26539
26540 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26541 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26544 if (SWIG_arg_fail(1)) SWIG_fail;
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26548
26549 wxPyEndAllowThreads(__tstate);
26550 if (PyErr_Occurred()) SWIG_fail;
26551 }
26552 Py_INCREF(Py_None); resultobj = Py_None;
26553 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26554 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26555 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26556 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26564 PyObject *resultobj;
26565 wxWindow *arg1 = (wxWindow *) 0 ;
26566 wxSize result;
26567 PyObject * obj0 = 0 ;
26568 char *kwnames[] = {
26569 (char *) "self", NULL
26570 };
26571
26572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26574 if (SWIG_arg_fail(1)) SWIG_fail;
26575 {
26576 PyThreadState* __tstate = wxPyBeginAllowThreads();
26577 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26578
26579 wxPyEndAllowThreads(__tstate);
26580 if (PyErr_Occurred()) SWIG_fail;
26581 }
26582 {
26583 wxSize * resultptr;
26584 resultptr = new wxSize((wxSize &)(result));
26585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26586 }
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26594 PyObject *resultobj;
26595 wxWindow *arg1 = (wxWindow *) 0 ;
26596 bool arg2 = (bool) true ;
26597 bool result;
26598 PyObject * obj0 = 0 ;
26599 PyObject * obj1 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self",(char *) "show", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 if (obj1) {
26608 {
26609 arg2 = (bool)(SWIG_As_bool(obj1));
26610 if (SWIG_arg_fail(2)) SWIG_fail;
26611 }
26612 }
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (bool)(arg1)->Show(arg2);
26616
26617 wxPyEndAllowThreads(__tstate);
26618 if (PyErr_Occurred()) SWIG_fail;
26619 }
26620 {
26621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26622 }
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26630 PyObject *resultobj;
26631 wxWindow *arg1 = (wxWindow *) 0 ;
26632 bool result;
26633 PyObject * obj0 = 0 ;
26634 char *kwnames[] = {
26635 (char *) "self", NULL
26636 };
26637
26638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26640 if (SWIG_arg_fail(1)) SWIG_fail;
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (bool)(arg1)->Hide();
26644
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 {
26649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26650 }
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj;
26659 wxWindow *arg1 = (wxWindow *) 0 ;
26660 bool arg2 = (bool) true ;
26661 bool result;
26662 PyObject * obj0 = 0 ;
26663 PyObject * obj1 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self",(char *) "enable", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 if (obj1) {
26672 {
26673 arg2 = (bool)(SWIG_As_bool(obj1));
26674 if (SWIG_arg_fail(2)) SWIG_fail;
26675 }
26676 }
26677 {
26678 PyThreadState* __tstate = wxPyBeginAllowThreads();
26679 result = (bool)(arg1)->Enable(arg2);
26680
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 {
26685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26686 }
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 bool result;
26697 PyObject * obj0 = 0 ;
26698 char *kwnames[] = {
26699 (char *) "self", NULL
26700 };
26701
26702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 {
26706 PyThreadState* __tstate = wxPyBeginAllowThreads();
26707 result = (bool)(arg1)->Disable();
26708
26709 wxPyEndAllowThreads(__tstate);
26710 if (PyErr_Occurred()) SWIG_fail;
26711 }
26712 {
26713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26714 }
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj;
26723 wxWindow *arg1 = (wxWindow *) 0 ;
26724 bool result;
26725 PyObject * obj0 = 0 ;
26726 char *kwnames[] = {
26727 (char *) "self", NULL
26728 };
26729
26730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26732 if (SWIG_arg_fail(1)) SWIG_fail;
26733 {
26734 PyThreadState* __tstate = wxPyBeginAllowThreads();
26735 result = (bool)((wxWindow const *)arg1)->IsShown();
26736
26737 wxPyEndAllowThreads(__tstate);
26738 if (PyErr_Occurred()) SWIG_fail;
26739 }
26740 {
26741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26742 }
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj;
26751 wxWindow *arg1 = (wxWindow *) 0 ;
26752 bool result;
26753 PyObject * obj0 = 0 ;
26754 char *kwnames[] = {
26755 (char *) "self", NULL
26756 };
26757
26758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26760 if (SWIG_arg_fail(1)) SWIG_fail;
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26764
26765 wxPyEndAllowThreads(__tstate);
26766 if (PyErr_Occurred()) SWIG_fail;
26767 }
26768 {
26769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26770 }
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj;
26779 wxWindow *arg1 = (wxWindow *) 0 ;
26780 long arg2 ;
26781 PyObject * obj0 = 0 ;
26782 PyObject * obj1 = 0 ;
26783 char *kwnames[] = {
26784 (char *) "self",(char *) "style", NULL
26785 };
26786
26787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26789 if (SWIG_arg_fail(1)) SWIG_fail;
26790 {
26791 arg2 = (long)(SWIG_As_long(obj1));
26792 if (SWIG_arg_fail(2)) SWIG_fail;
26793 }
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 (arg1)->SetWindowStyleFlag(arg2);
26797
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 Py_INCREF(Py_None); resultobj = Py_None;
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj;
26810 wxWindow *arg1 = (wxWindow *) 0 ;
26811 long result;
26812 PyObject * obj0 = 0 ;
26813 char *kwnames[] = {
26814 (char *) "self", NULL
26815 };
26816
26817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26819 if (SWIG_arg_fail(1)) SWIG_fail;
26820 {
26821 PyThreadState* __tstate = wxPyBeginAllowThreads();
26822 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26823
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 {
26828 resultobj = SWIG_From_long((long)(result));
26829 }
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26837 PyObject *resultobj;
26838 wxWindow *arg1 = (wxWindow *) 0 ;
26839 int arg2 ;
26840 bool result;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char *kwnames[] = {
26844 (char *) "self",(char *) "flag", NULL
26845 };
26846
26847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26849 if (SWIG_arg_fail(1)) SWIG_fail;
26850 {
26851 arg2 = (int)(SWIG_As_int(obj1));
26852 if (SWIG_arg_fail(2)) SWIG_fail;
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26857
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 {
26862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26863 }
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26871 PyObject *resultobj;
26872 wxWindow *arg1 = (wxWindow *) 0 ;
26873 bool result;
26874 PyObject * obj0 = 0 ;
26875 char *kwnames[] = {
26876 (char *) "self", NULL
26877 };
26878
26879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26881 if (SWIG_arg_fail(1)) SWIG_fail;
26882 {
26883 PyThreadState* __tstate = wxPyBeginAllowThreads();
26884 result = (bool)((wxWindow const *)arg1)->IsRetained();
26885
26886 wxPyEndAllowThreads(__tstate);
26887 if (PyErr_Occurred()) SWIG_fail;
26888 }
26889 {
26890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26891 }
26892 return resultobj;
26893 fail:
26894 return NULL;
26895 }
26896
26897
26898 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj;
26900 wxWindow *arg1 = (wxWindow *) 0 ;
26901 long arg2 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char *kwnames[] = {
26905 (char *) "self",(char *) "exStyle", NULL
26906 };
26907
26908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26910 if (SWIG_arg_fail(1)) SWIG_fail;
26911 {
26912 arg2 = (long)(SWIG_As_long(obj1));
26913 if (SWIG_arg_fail(2)) SWIG_fail;
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetExtraStyle(arg2);
26918
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 Py_INCREF(Py_None); resultobj = Py_None;
26923 return resultobj;
26924 fail:
26925 return NULL;
26926 }
26927
26928
26929 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26930 PyObject *resultobj;
26931 wxWindow *arg1 = (wxWindow *) 0 ;
26932 long result;
26933 PyObject * obj0 = 0 ;
26934 char *kwnames[] = {
26935 (char *) "self", NULL
26936 };
26937
26938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26940 if (SWIG_arg_fail(1)) SWIG_fail;
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26944
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 {
26949 resultobj = SWIG_From_long((long)(result));
26950 }
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26958 PyObject *resultobj;
26959 wxWindow *arg1 = (wxWindow *) 0 ;
26960 bool arg2 = (bool) true ;
26961 PyObject * obj0 = 0 ;
26962 PyObject * obj1 = 0 ;
26963 char *kwnames[] = {
26964 (char *) "self",(char *) "modal", NULL
26965 };
26966
26967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26969 if (SWIG_arg_fail(1)) SWIG_fail;
26970 if (obj1) {
26971 {
26972 arg2 = (bool)(SWIG_As_bool(obj1));
26973 if (SWIG_arg_fail(2)) SWIG_fail;
26974 }
26975 }
26976 {
26977 PyThreadState* __tstate = wxPyBeginAllowThreads();
26978 (arg1)->MakeModal(arg2);
26979
26980 wxPyEndAllowThreads(__tstate);
26981 if (PyErr_Occurred()) SWIG_fail;
26982 }
26983 Py_INCREF(Py_None); resultobj = Py_None;
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj;
26992 wxWindow *arg1 = (wxWindow *) 0 ;
26993 bool arg2 ;
26994 PyObject * obj0 = 0 ;
26995 PyObject * obj1 = 0 ;
26996 char *kwnames[] = {
26997 (char *) "self",(char *) "enableTheme", NULL
26998 };
26999
27000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27002 if (SWIG_arg_fail(1)) SWIG_fail;
27003 {
27004 arg2 = (bool)(SWIG_As_bool(obj1));
27005 if (SWIG_arg_fail(2)) SWIG_fail;
27006 }
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 (arg1)->SetThemeEnabled(arg2);
27010
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 Py_INCREF(Py_None); resultobj = Py_None;
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj;
27023 wxWindow *arg1 = (wxWindow *) 0 ;
27024 bool result;
27025 PyObject * obj0 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27036
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 {
27041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27042 }
27043 return resultobj;
27044 fail:
27045 return NULL;
27046 }
27047
27048
27049 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27050 PyObject *resultobj;
27051 wxWindow *arg1 = (wxWindow *) 0 ;
27052 PyObject * obj0 = 0 ;
27053 char *kwnames[] = {
27054 (char *) "self", NULL
27055 };
27056
27057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27059 if (SWIG_arg_fail(1)) SWIG_fail;
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 (arg1)->SetFocus();
27063
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 Py_INCREF(Py_None); resultobj = Py_None;
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj;
27076 wxWindow *arg1 = (wxWindow *) 0 ;
27077 PyObject * obj0 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self", NULL
27080 };
27081
27082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27084 if (SWIG_arg_fail(1)) SWIG_fail;
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 (arg1)->SetFocusFromKbd();
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 Py_INCREF(Py_None); resultobj = Py_None;
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj;
27101 wxWindow *result;
27102 char *kwnames[] = {
27103 NULL
27104 };
27105
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27107 {
27108 if (!wxPyCheckForApp()) SWIG_fail;
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (wxWindow *)wxWindow::FindFocus();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = wxPyMake_wxObject(result, 0);
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 bool result;
27128 PyObject * obj0 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 bool result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 wxWindow *result;
27184 PyObject * obj0 = 0 ;
27185 char *kwnames[] = {
27186 (char *) "self", NULL
27187 };
27188
27189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(1)) SWIG_fail;
27192 {
27193 PyThreadState* __tstate = wxPyBeginAllowThreads();
27194 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27195
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = wxPyMake_wxObject(result, 0);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj;
27210 wxWindow *arg1 = (wxWindow *) 0 ;
27211 wxWindow *arg2 = (wxWindow *) 0 ;
27212 wxWindow *result;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self",(char *) "child", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27223 if (SWIG_arg_fail(2)) SWIG_fail;
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27227
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = wxPyMake_wxObject(result, 0);
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 wxWindow *arg2 = (wxWindow *) 0 ;
27244 PyObject * obj0 = 0 ;
27245 PyObject * obj1 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self",(char *) "win", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27254 if (SWIG_arg_fail(2)) SWIG_fail;
27255 {
27256 PyThreadState* __tstate = wxPyBeginAllowThreads();
27257 (arg1)->SetTmpDefaultItem(arg2);
27258
27259 wxPyEndAllowThreads(__tstate);
27260 if (PyErr_Occurred()) SWIG_fail;
27261 }
27262 Py_INCREF(Py_None); resultobj = Py_None;
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj;
27271 wxWindow *arg1 = (wxWindow *) 0 ;
27272 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27273 bool result;
27274 PyObject * obj0 = 0 ;
27275 PyObject * obj1 = 0 ;
27276 char *kwnames[] = {
27277 (char *) "self",(char *) "flags", NULL
27278 };
27279
27280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27282 if (SWIG_arg_fail(1)) SWIG_fail;
27283 if (obj1) {
27284 {
27285 arg2 = (int)(SWIG_As_int(obj1));
27286 if (SWIG_arg_fail(2)) SWIG_fail;
27287 }
27288 }
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = (bool)(arg1)->Navigate(arg2);
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27298 }
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27306 PyObject *resultobj;
27307 wxWindow *arg1 = (wxWindow *) 0 ;
27308 wxWindow *arg2 = (wxWindow *) 0 ;
27309 PyObject * obj0 = 0 ;
27310 PyObject * obj1 = 0 ;
27311 char *kwnames[] = {
27312 (char *) "self",(char *) "win", NULL
27313 };
27314
27315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(1)) SWIG_fail;
27318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27319 if (SWIG_arg_fail(2)) SWIG_fail;
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 (arg1)->MoveAfterInTabOrder(arg2);
27323
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 Py_INCREF(Py_None); resultobj = Py_None;
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj;
27336 wxWindow *arg1 = (wxWindow *) 0 ;
27337 wxWindow *arg2 = (wxWindow *) 0 ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char *kwnames[] = {
27341 (char *) "self",(char *) "win", NULL
27342 };
27343
27344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27346 if (SWIG_arg_fail(1)) SWIG_fail;
27347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27348 if (SWIG_arg_fail(2)) SWIG_fail;
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 (arg1)->MoveBeforeInTabOrder(arg2);
27352
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 Py_INCREF(Py_None); resultobj = Py_None;
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27364 PyObject *resultobj;
27365 wxWindow *arg1 = (wxWindow *) 0 ;
27366 PyObject *result;
27367 PyObject * obj0 = 0 ;
27368 char *kwnames[] = {
27369 (char *) "self", NULL
27370 };
27371
27372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27374 if (SWIG_arg_fail(1)) SWIG_fail;
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (PyObject *)wxWindow_GetChildren(arg1);
27378
27379 wxPyEndAllowThreads(__tstate);
27380 if (PyErr_Occurred()) SWIG_fail;
27381 }
27382 resultobj = result;
27383 return resultobj;
27384 fail:
27385 return NULL;
27386 }
27387
27388
27389 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj;
27391 wxWindow *arg1 = (wxWindow *) 0 ;
27392 wxWindow *result;
27393 PyObject * obj0 = 0 ;
27394 char *kwnames[] = {
27395 (char *) "self", NULL
27396 };
27397
27398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27400 if (SWIG_arg_fail(1)) SWIG_fail;
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27404
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 {
27409 resultobj = wxPyMake_wxObject(result, 0);
27410 }
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj;
27419 wxWindow *arg1 = (wxWindow *) 0 ;
27420 wxWindow *result;
27421 PyObject * obj0 = 0 ;
27422 char *kwnames[] = {
27423 (char *) "self", NULL
27424 };
27425
27426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27428 if (SWIG_arg_fail(1)) SWIG_fail;
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27432
27433 wxPyEndAllowThreads(__tstate);
27434 if (PyErr_Occurred()) SWIG_fail;
27435 }
27436 {
27437 resultobj = wxPyMake_wxObject(result, 0);
27438 }
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj;
27447 wxWindow *arg1 = (wxWindow *) 0 ;
27448 bool result;
27449 PyObject * obj0 = 0 ;
27450 char *kwnames[] = {
27451 (char *) "self", NULL
27452 };
27453
27454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27456 if (SWIG_arg_fail(1)) SWIG_fail;
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27460
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27466 }
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27474 PyObject *resultobj;
27475 wxWindow *arg1 = (wxWindow *) 0 ;
27476 wxWindow *arg2 = (wxWindow *) 0 ;
27477 bool result;
27478 PyObject * obj0 = 0 ;
27479 PyObject * obj1 = 0 ;
27480 char *kwnames[] = {
27481 (char *) "self",(char *) "newParent", NULL
27482 };
27483
27484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27486 if (SWIG_arg_fail(1)) SWIG_fail;
27487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(2)) SWIG_fail;
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 result = (bool)(arg1)->Reparent(arg2);
27492
27493 wxPyEndAllowThreads(__tstate);
27494 if (PyErr_Occurred()) SWIG_fail;
27495 }
27496 {
27497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27498 }
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27506 PyObject *resultobj;
27507 wxWindow *arg1 = (wxWindow *) 0 ;
27508 wxWindow *arg2 = (wxWindow *) 0 ;
27509 PyObject * obj0 = 0 ;
27510 PyObject * obj1 = 0 ;
27511 char *kwnames[] = {
27512 (char *) "self",(char *) "child", NULL
27513 };
27514
27515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(1)) SWIG_fail;
27518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27519 if (SWIG_arg_fail(2)) SWIG_fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 (arg1)->AddChild(arg2);
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 Py_INCREF(Py_None); resultobj = Py_None;
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 wxWindow *arg2 = (wxWindow *) 0 ;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "child", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(2)) SWIG_fail;
27549 {
27550 PyThreadState* __tstate = wxPyBeginAllowThreads();
27551 (arg1)->RemoveChild(arg2);
27552
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 Py_INCREF(Py_None); resultobj = Py_None;
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27564 PyObject *resultobj;
27565 wxWindow *arg1 = (wxWindow *) 0 ;
27566 long arg2 ;
27567 wxWindow *result;
27568 PyObject * obj0 = 0 ;
27569 PyObject * obj1 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "winid", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 {
27578 arg2 = (long)(SWIG_As_long(obj1));
27579 if (SWIG_arg_fail(2)) SWIG_fail;
27580 }
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 result = (wxWindow *)(arg1)->FindWindow(arg2);
27584
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = wxPyMake_wxObject(result, 0);
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj;
27599 wxWindow *arg1 = (wxWindow *) 0 ;
27600 wxString *arg2 = 0 ;
27601 wxWindow *result;
27602 bool temp2 = false ;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char *kwnames[] = {
27606 (char *) "self",(char *) "name", NULL
27607 };
27608
27609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27611 if (SWIG_arg_fail(1)) SWIG_fail;
27612 {
27613 arg2 = wxString_in_helper(obj1);
27614 if (arg2 == NULL) SWIG_fail;
27615 temp2 = true;
27616 }
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = wxPyMake_wxObject(result, 0);
27626 }
27627 {
27628 if (temp2)
27629 delete arg2;
27630 }
27631 return resultobj;
27632 fail:
27633 {
27634 if (temp2)
27635 delete arg2;
27636 }
27637 return NULL;
27638 }
27639
27640
27641 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27642 PyObject *resultobj;
27643 wxWindow *arg1 = (wxWindow *) 0 ;
27644 wxEvtHandler *result;
27645 PyObject * obj0 = 0 ;
27646 char *kwnames[] = {
27647 (char *) "self", NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27652 if (SWIG_arg_fail(1)) SWIG_fail;
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 {
27661 resultobj = wxPyMake_wxObject(result, 0);
27662 }
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27670 PyObject *resultobj;
27671 wxWindow *arg1 = (wxWindow *) 0 ;
27672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27673 PyObject * obj0 = 0 ;
27674 PyObject * obj1 = 0 ;
27675 char *kwnames[] = {
27676 (char *) "self",(char *) "handler", NULL
27677 };
27678
27679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(1)) SWIG_fail;
27682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27683 if (SWIG_arg_fail(2)) SWIG_fail;
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->SetEventHandler(arg2);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 Py_INCREF(Py_None); resultobj = Py_None;
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27702 PyObject * obj0 = 0 ;
27703 PyObject * obj1 = 0 ;
27704 char *kwnames[] = {
27705 (char *) "self",(char *) "handler", NULL
27706 };
27707
27708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(1)) SWIG_fail;
27711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27712 if (SWIG_arg_fail(2)) SWIG_fail;
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->PushEventHandler(arg2);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 Py_INCREF(Py_None); resultobj = Py_None;
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxWindow *arg1 = (wxWindow *) 0 ;
27730 bool arg2 = (bool) false ;
27731 wxEvtHandler *result;
27732 PyObject * obj0 = 0 ;
27733 PyObject * obj1 = 0 ;
27734 char *kwnames[] = {
27735 (char *) "self",(char *) "deleteHandler", NULL
27736 };
27737
27738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27740 if (SWIG_arg_fail(1)) SWIG_fail;
27741 if (obj1) {
27742 {
27743 arg2 = (bool)(SWIG_As_bool(obj1));
27744 if (SWIG_arg_fail(2)) SWIG_fail;
27745 }
27746 }
27747 {
27748 PyThreadState* __tstate = wxPyBeginAllowThreads();
27749 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27750
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 resultobj = wxPyMake_wxObject(result, 0);
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27764 PyObject *resultobj;
27765 wxWindow *arg1 = (wxWindow *) 0 ;
27766 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27767 bool result;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char *kwnames[] = {
27771 (char *) "self",(char *) "handler", NULL
27772 };
27773
27774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27776 if (SWIG_arg_fail(1)) SWIG_fail;
27777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27778 if (SWIG_arg_fail(2)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (bool)(arg1)->RemoveEventHandler(arg2);
27782
27783 wxPyEndAllowThreads(__tstate);
27784 if (PyErr_Occurred()) SWIG_fail;
27785 }
27786 {
27787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27788 }
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj;
27797 wxWindow *arg1 = (wxWindow *) 0 ;
27798 wxValidator *arg2 = 0 ;
27799 PyObject * obj0 = 0 ;
27800 PyObject * obj1 = 0 ;
27801 char *kwnames[] = {
27802 (char *) "self",(char *) "validator", NULL
27803 };
27804
27805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27807 if (SWIG_arg_fail(1)) SWIG_fail;
27808 {
27809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(2)) SWIG_fail;
27811 if (arg2 == NULL) {
27812 SWIG_null_ref("wxValidator");
27813 }
27814 if (SWIG_arg_fail(2)) SWIG_fail;
27815 }
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 (arg1)->SetValidator((wxValidator const &)*arg2);
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 Py_INCREF(Py_None); resultobj = Py_None;
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 wxValidator *result;
27834 PyObject * obj0 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (wxValidator *)(arg1)->GetValidator();
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 resultobj = wxPyMake_wxObject(result, 0);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 bool result;
27862 PyObject * obj0 = 0 ;
27863 char *kwnames[] = {
27864 (char *) "self", NULL
27865 };
27866
27867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27869 if (SWIG_arg_fail(1)) SWIG_fail;
27870 {
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (bool)(arg1)->Validate();
27873
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 {
27878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxWindow *arg1 = (wxWindow *) 0 ;
27889 bool result;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 result = (bool)(arg1)->TransferDataToWindow();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 {
27906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27907 }
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxWindow *arg1 = (wxWindow *) 0 ;
27917 bool result;
27918 PyObject * obj0 = 0 ;
27919 char *kwnames[] = {
27920 (char *) "self", NULL
27921 };
27922
27923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27925 if (SWIG_arg_fail(1)) SWIG_fail;
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (bool)(arg1)->TransferDataFromWindow();
27929
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 {
27934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27935 }
27936 return resultobj;
27937 fail:
27938 return NULL;
27939 }
27940
27941
27942 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj;
27944 wxWindow *arg1 = (wxWindow *) 0 ;
27945 PyObject * obj0 = 0 ;
27946 char *kwnames[] = {
27947 (char *) "self", NULL
27948 };
27949
27950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27952 if (SWIG_arg_fail(1)) SWIG_fail;
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 (arg1)->InitDialog();
27956
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 Py_INCREF(Py_None); resultobj = Py_None;
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxWindow *arg1 = (wxWindow *) 0 ;
27970 wxAcceleratorTable *arg2 = 0 ;
27971 PyObject * obj0 = 0 ;
27972 PyObject * obj1 = 0 ;
27973 char *kwnames[] = {
27974 (char *) "self",(char *) "accel", NULL
27975 };
27976
27977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27979 if (SWIG_arg_fail(1)) SWIG_fail;
27980 {
27981 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27982 if (SWIG_arg_fail(2)) SWIG_fail;
27983 if (arg2 == NULL) {
27984 SWIG_null_ref("wxAcceleratorTable");
27985 }
27986 if (SWIG_arg_fail(2)) SWIG_fail;
27987 }
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 Py_INCREF(Py_None); resultobj = Py_None;
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj;
28004 wxWindow *arg1 = (wxWindow *) 0 ;
28005 wxAcceleratorTable *result;
28006 PyObject * obj0 = 0 ;
28007 char *kwnames[] = {
28008 (char *) "self", NULL
28009 };
28010
28011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28013 if (SWIG_arg_fail(1)) SWIG_fail;
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28017
28018 wxPyEndAllowThreads(__tstate);
28019 if (PyErr_Occurred()) SWIG_fail;
28020 }
28021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28022 return resultobj;
28023 fail:
28024 return NULL;
28025 }
28026
28027
28028 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28029 PyObject *resultobj;
28030 wxWindow *arg1 = (wxWindow *) 0 ;
28031 int arg2 ;
28032 int arg3 ;
28033 int arg4 ;
28034 bool result;
28035 PyObject * obj0 = 0 ;
28036 PyObject * obj1 = 0 ;
28037 PyObject * obj2 = 0 ;
28038 PyObject * obj3 = 0 ;
28039 char *kwnames[] = {
28040 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28041 };
28042
28043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28045 if (SWIG_arg_fail(1)) SWIG_fail;
28046 {
28047 arg2 = (int)(SWIG_As_int(obj1));
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 }
28050 {
28051 arg3 = (int)(SWIG_As_int(obj2));
28052 if (SWIG_arg_fail(3)) SWIG_fail;
28053 }
28054 {
28055 arg4 = (int)(SWIG_As_int(obj3));
28056 if (SWIG_arg_fail(4)) SWIG_fail;
28057 }
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28061
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 {
28066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28067 }
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj;
28076 wxWindow *arg1 = (wxWindow *) 0 ;
28077 int arg2 ;
28078 bool result;
28079 PyObject * obj0 = 0 ;
28080 PyObject * obj1 = 0 ;
28081 char *kwnames[] = {
28082 (char *) "self",(char *) "hotkeyId", NULL
28083 };
28084
28085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28087 if (SWIG_arg_fail(1)) SWIG_fail;
28088 {
28089 arg2 = (int)(SWIG_As_int(obj1));
28090 if (SWIG_arg_fail(2)) SWIG_fail;
28091 }
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28095
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 {
28100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28101 }
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 wxPoint *arg2 = 0 ;
28112 wxPoint result;
28113 wxPoint temp2 ;
28114 PyObject * obj0 = 0 ;
28115 PyObject * obj1 = 0 ;
28116 char *kwnames[] = {
28117 (char *) "self",(char *) "pt", NULL
28118 };
28119
28120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28122 if (SWIG_arg_fail(1)) SWIG_fail;
28123 {
28124 arg2 = &temp2;
28125 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28126 }
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28130
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 {
28135 wxPoint * resultptr;
28136 resultptr = new wxPoint((wxPoint &)(result));
28137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28138 }
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28146 PyObject *resultobj;
28147 wxWindow *arg1 = (wxWindow *) 0 ;
28148 wxSize *arg2 = 0 ;
28149 wxSize result;
28150 wxSize temp2 ;
28151 PyObject * obj0 = 0 ;
28152 PyObject * obj1 = 0 ;
28153 char *kwnames[] = {
28154 (char *) "self",(char *) "sz", NULL
28155 };
28156
28157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28159 if (SWIG_arg_fail(1)) SWIG_fail;
28160 {
28161 arg2 = &temp2;
28162 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28163 }
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 wxSize * resultptr;
28173 resultptr = new wxSize((wxSize &)(result));
28174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28175 }
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxWindow *arg1 = (wxWindow *) 0 ;
28185 wxPoint *arg2 = 0 ;
28186 wxPoint result;
28187 wxPoint temp2 ;
28188 PyObject * obj0 = 0 ;
28189 PyObject * obj1 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self",(char *) "pt", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 {
28198 arg2 = &temp2;
28199 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28200 }
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28204
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 {
28209 wxPoint * resultptr;
28210 resultptr = new wxPoint((wxPoint &)(result));
28211 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28212 }
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj;
28221 wxWindow *arg1 = (wxWindow *) 0 ;
28222 wxSize *arg2 = 0 ;
28223 wxSize result;
28224 wxSize temp2 ;
28225 PyObject * obj0 = 0 ;
28226 PyObject * obj1 = 0 ;
28227 char *kwnames[] = {
28228 (char *) "self",(char *) "sz", NULL
28229 };
28230
28231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28233 if (SWIG_arg_fail(1)) SWIG_fail;
28234 {
28235 arg2 = &temp2;
28236 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28237 }
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28241
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 wxSize * resultptr;
28247 resultptr = new wxSize((wxSize &)(result));
28248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28249 }
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28257 PyObject *resultobj;
28258 wxWindow *arg1 = (wxWindow *) 0 ;
28259 wxPoint *arg2 = 0 ;
28260 wxPoint result;
28261 wxPoint temp2 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char *kwnames[] = {
28265 (char *) "self",(char *) "pt", NULL
28266 };
28267
28268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28270 if (SWIG_arg_fail(1)) SWIG_fail;
28271 {
28272 arg2 = &temp2;
28273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28274 }
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28278
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 {
28283 wxPoint * resultptr;
28284 resultptr = new wxPoint((wxPoint &)(result));
28285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28286 }
28287 return resultobj;
28288 fail:
28289 return NULL;
28290 }
28291
28292
28293 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28294 PyObject *resultobj;
28295 wxWindow *arg1 = (wxWindow *) 0 ;
28296 wxSize *arg2 = 0 ;
28297 wxSize result;
28298 wxSize temp2 ;
28299 PyObject * obj0 = 0 ;
28300 PyObject * obj1 = 0 ;
28301 char *kwnames[] = {
28302 (char *) "self",(char *) "sz", NULL
28303 };
28304
28305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28307 if (SWIG_arg_fail(1)) SWIG_fail;
28308 {
28309 arg2 = &temp2;
28310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 wxSize * resultptr;
28321 resultptr = new wxSize((wxSize &)(result));
28322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28323 }
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj;
28332 wxWindow *arg1 = (wxWindow *) 0 ;
28333 int arg2 ;
28334 int arg3 ;
28335 PyObject * obj0 = 0 ;
28336 PyObject * obj1 = 0 ;
28337 PyObject * obj2 = 0 ;
28338 char *kwnames[] = {
28339 (char *) "self",(char *) "x",(char *) "y", NULL
28340 };
28341
28342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28344 if (SWIG_arg_fail(1)) SWIG_fail;
28345 {
28346 arg2 = (int)(SWIG_As_int(obj1));
28347 if (SWIG_arg_fail(2)) SWIG_fail;
28348 }
28349 {
28350 arg3 = (int)(SWIG_As_int(obj2));
28351 if (SWIG_arg_fail(3)) SWIG_fail;
28352 }
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 (arg1)->WarpPointer(arg2,arg3);
28356
28357 wxPyEndAllowThreads(__tstate);
28358 if (PyErr_Occurred()) SWIG_fail;
28359 }
28360 Py_INCREF(Py_None); resultobj = Py_None;
28361 return resultobj;
28362 fail:
28363 return NULL;
28364 }
28365
28366
28367 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28368 PyObject *resultobj;
28369 wxWindow *arg1 = (wxWindow *) 0 ;
28370 PyObject * obj0 = 0 ;
28371 char *kwnames[] = {
28372 (char *) "self", NULL
28373 };
28374
28375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28377 if (SWIG_arg_fail(1)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 (arg1)->CaptureMouse();
28381
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 Py_INCREF(Py_None); resultobj = Py_None;
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28393 PyObject *resultobj;
28394 wxWindow *arg1 = (wxWindow *) 0 ;
28395 PyObject * obj0 = 0 ;
28396 char *kwnames[] = {
28397 (char *) "self", NULL
28398 };
28399
28400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(1)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 (arg1)->ReleaseMouse();
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 Py_INCREF(Py_None); resultobj = Py_None;
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj;
28419 wxWindow *result;
28420 char *kwnames[] = {
28421 NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28425 {
28426 if (!wxPyCheckForApp()) SWIG_fail;
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = (wxWindow *)wxWindow::GetCapture();
28429
28430 wxPyEndAllowThreads(__tstate);
28431 if (PyErr_Occurred()) SWIG_fail;
28432 }
28433 {
28434 resultobj = wxPyMake_wxObject(result, 0);
28435 }
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxWindow *arg1 = (wxWindow *) 0 ;
28445 bool result;
28446 PyObject * obj0 = 0 ;
28447 char *kwnames[] = {
28448 (char *) "self", NULL
28449 };
28450
28451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(1)) SWIG_fail;
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)((wxWindow const *)arg1)->HasCapture();
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 {
28462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxWindow *arg1 = (wxWindow *) 0 ;
28473 bool arg2 = (bool) true ;
28474 wxRect *arg3 = (wxRect *) NULL ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28477 PyObject * obj2 = 0 ;
28478 char *kwnames[] = {
28479 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28480 };
28481
28482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(1)) SWIG_fail;
28485 if (obj1) {
28486 {
28487 arg2 = (bool)(SWIG_As_bool(obj1));
28488 if (SWIG_arg_fail(2)) SWIG_fail;
28489 }
28490 }
28491 if (obj2) {
28492 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(3)) SWIG_fail;
28494 }
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28498
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 Py_INCREF(Py_None); resultobj = Py_None;
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28510 PyObject *resultobj;
28511 wxWindow *arg1 = (wxWindow *) 0 ;
28512 wxRect *arg2 = 0 ;
28513 wxRect temp2 ;
28514 PyObject * obj0 = 0 ;
28515 PyObject * obj1 = 0 ;
28516 char *kwnames[] = {
28517 (char *) "self",(char *) "rect", NULL
28518 };
28519
28520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(1)) SWIG_fail;
28523 {
28524 arg2 = &temp2;
28525 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28526 }
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 (arg1)->RefreshRect((wxRect const &)*arg2);
28530
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 Py_INCREF(Py_None); resultobj = Py_None;
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj;
28543 wxWindow *arg1 = (wxWindow *) 0 ;
28544 PyObject * obj0 = 0 ;
28545 char *kwnames[] = {
28546 (char *) "self", NULL
28547 };
28548
28549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(1)) SWIG_fail;
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 (arg1)->Update();
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 Py_INCREF(Py_None); resultobj = Py_None;
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxWindow *arg1 = (wxWindow *) 0 ;
28569 PyObject * obj0 = 0 ;
28570 char *kwnames[] = {
28571 (char *) "self", NULL
28572 };
28573
28574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28576 if (SWIG_arg_fail(1)) SWIG_fail;
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 (arg1)->ClearBackground();
28580
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 Py_INCREF(Py_None); resultobj = Py_None;
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28592 PyObject *resultobj;
28593 wxWindow *arg1 = (wxWindow *) 0 ;
28594 PyObject * obj0 = 0 ;
28595 char *kwnames[] = {
28596 (char *) "self", NULL
28597 };
28598
28599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(1)) SWIG_fail;
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 (arg1)->Freeze();
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 Py_INCREF(Py_None); resultobj = Py_None;
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj;
28618 wxWindow *arg1 = (wxWindow *) 0 ;
28619 PyObject * obj0 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 (arg1)->Thaw();
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 Py_INCREF(Py_None); resultobj = Py_None;
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxWindow *arg1 = (wxWindow *) 0 ;
28644 wxDC *arg2 = 0 ;
28645 PyObject * obj0 = 0 ;
28646 PyObject * obj1 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self",(char *) "dc", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(2)) SWIG_fail;
28657 if (arg2 == NULL) {
28658 SWIG_null_ref("wxDC");
28659 }
28660 if (SWIG_arg_fail(2)) SWIG_fail;
28661 }
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 (arg1)->PrepareDC(*arg2);
28665
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 Py_INCREF(Py_None); resultobj = Py_None;
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj;
28678 wxWindow *arg1 = (wxWindow *) 0 ;
28679 wxRegion *result;
28680 PyObject * obj0 = 0 ;
28681 char *kwnames[] = {
28682 (char *) "self", NULL
28683 };
28684
28685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28687 if (SWIG_arg_fail(1)) SWIG_fail;
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 {
28691 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28692 result = (wxRegion *) &_result_ref;
28693 }
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj;
28707 wxWindow *arg1 = (wxWindow *) 0 ;
28708 wxRect result;
28709 PyObject * obj0 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28720
28721 wxPyEndAllowThreads(__tstate);
28722 if (PyErr_Occurred()) SWIG_fail;
28723 }
28724 {
28725 wxRect * resultptr;
28726 resultptr = new wxRect((wxRect &)(result));
28727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28728 }
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj;
28737 wxWindow *arg1 = (wxWindow *) 0 ;
28738 int arg2 ;
28739 int arg3 ;
28740 int arg4 = (int) 1 ;
28741 int arg5 = (int) 1 ;
28742 bool result;
28743 PyObject * obj0 = 0 ;
28744 PyObject * obj1 = 0 ;
28745 PyObject * obj2 = 0 ;
28746 PyObject * obj3 = 0 ;
28747 PyObject * obj4 = 0 ;
28748 char *kwnames[] = {
28749 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28750 };
28751
28752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(1)) SWIG_fail;
28755 {
28756 arg2 = (int)(SWIG_As_int(obj1));
28757 if (SWIG_arg_fail(2)) SWIG_fail;
28758 }
28759 {
28760 arg3 = (int)(SWIG_As_int(obj2));
28761 if (SWIG_arg_fail(3)) SWIG_fail;
28762 }
28763 if (obj3) {
28764 {
28765 arg4 = (int)(SWIG_As_int(obj3));
28766 if (SWIG_arg_fail(4)) SWIG_fail;
28767 }
28768 }
28769 if (obj4) {
28770 {
28771 arg5 = (int)(SWIG_As_int(obj4));
28772 if (SWIG_arg_fail(5)) SWIG_fail;
28773 }
28774 }
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28778
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28784 }
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj;
28793 wxWindow *arg1 = (wxWindow *) 0 ;
28794 wxPoint *arg2 = 0 ;
28795 bool result;
28796 wxPoint temp2 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 char *kwnames[] = {
28800 (char *) "self",(char *) "pt", NULL
28801 };
28802
28803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28805 if (SWIG_arg_fail(1)) SWIG_fail;
28806 {
28807 arg2 = &temp2;
28808 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28809 }
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28827 PyObject *resultobj;
28828 wxWindow *arg1 = (wxWindow *) 0 ;
28829 wxRect *arg2 = 0 ;
28830 bool result;
28831 wxRect temp2 ;
28832 PyObject * obj0 = 0 ;
28833 PyObject * obj1 = 0 ;
28834 char *kwnames[] = {
28835 (char *) "self",(char *) "rect", NULL
28836 };
28837
28838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28840 if (SWIG_arg_fail(1)) SWIG_fail;
28841 {
28842 arg2 = &temp2;
28843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28844 }
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28848
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 {
28853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28854 }
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj;
28863 wxWindow *arg1 = (wxWindow *) 0 ;
28864 wxVisualAttributes result;
28865 PyObject * obj0 = 0 ;
28866 char *kwnames[] = {
28867 (char *) "self", NULL
28868 };
28869
28870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28872 if (SWIG_arg_fail(1)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 wxVisualAttributes * resultptr;
28882 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj;
28893 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28894 wxVisualAttributes result;
28895 PyObject * obj0 = 0 ;
28896 char *kwnames[] = {
28897 (char *) "variant", NULL
28898 };
28899
28900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28901 if (obj0) {
28902 {
28903 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 }
28906 }
28907 {
28908 if (!wxPyCheckForApp()) SWIG_fail;
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28911
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 wxVisualAttributes * resultptr;
28917 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28919 }
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj;
28928 wxWindow *arg1 = (wxWindow *) 0 ;
28929 wxColour *arg2 = 0 ;
28930 bool result;
28931 wxColour temp2 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "colour", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = &temp2;
28943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 {
28953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28954 }
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28962 PyObject *resultobj;
28963 wxWindow *arg1 = (wxWindow *) 0 ;
28964 wxColour *arg2 = 0 ;
28965 wxColour temp2 ;
28966 PyObject * obj0 = 0 ;
28967 PyObject * obj1 = 0 ;
28968 char *kwnames[] = {
28969 (char *) "self",(char *) "colour", NULL
28970 };
28971
28972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28974 if (SWIG_arg_fail(1)) SWIG_fail;
28975 {
28976 arg2 = &temp2;
28977 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28982
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 Py_INCREF(Py_None); resultobj = Py_None;
28987 return resultobj;
28988 fail:
28989 return NULL;
28990 }
28991
28992
28993 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28994 PyObject *resultobj;
28995 wxWindow *arg1 = (wxWindow *) 0 ;
28996 wxColour *arg2 = 0 ;
28997 bool result;
28998 wxColour temp2 ;
28999 PyObject * obj0 = 0 ;
29000 PyObject * obj1 = 0 ;
29001 char *kwnames[] = {
29002 (char *) "self",(char *) "colour", NULL
29003 };
29004
29005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29007 if (SWIG_arg_fail(1)) SWIG_fail;
29008 {
29009 arg2 = &temp2;
29010 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29011 }
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 {
29020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29021 }
29022 return resultobj;
29023 fail:
29024 return NULL;
29025 }
29026
29027
29028 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29029 PyObject *resultobj;
29030 wxWindow *arg1 = (wxWindow *) 0 ;
29031 wxColour *arg2 = 0 ;
29032 wxColour temp2 ;
29033 PyObject * obj0 = 0 ;
29034 PyObject * obj1 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self",(char *) "colour", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 {
29043 arg2 = &temp2;
29044 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29045 }
29046 {
29047 PyThreadState* __tstate = wxPyBeginAllowThreads();
29048 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29049
29050 wxPyEndAllowThreads(__tstate);
29051 if (PyErr_Occurred()) SWIG_fail;
29052 }
29053 Py_INCREF(Py_None); resultobj = Py_None;
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj;
29062 wxWindow *arg1 = (wxWindow *) 0 ;
29063 wxColour result;
29064 PyObject * obj0 = 0 ;
29065 char *kwnames[] = {
29066 (char *) "self", NULL
29067 };
29068
29069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29071 if (SWIG_arg_fail(1)) SWIG_fail;
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29075
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 {
29080 wxColour * resultptr;
29081 resultptr = new wxColour((wxColour &)(result));
29082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29083 }
29084 return resultobj;
29085 fail:
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj;
29092 wxWindow *arg1 = (wxWindow *) 0 ;
29093 wxColour result;
29094 PyObject * obj0 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = ((wxWindow const *)arg1)->GetForegroundColour();
29105
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 {
29110 wxColour * resultptr;
29111 resultptr = new wxColour((wxColour &)(result));
29112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29113 }
29114 return resultobj;
29115 fail:
29116 return NULL;
29117 }
29118
29119
29120 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29121 PyObject *resultobj;
29122 wxWindow *arg1 = (wxWindow *) 0 ;
29123 wxBackgroundStyle arg2 ;
29124 bool result;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 char *kwnames[] = {
29128 (char *) "self",(char *) "style", NULL
29129 };
29130
29131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29133 if (SWIG_arg_fail(1)) SWIG_fail;
29134 {
29135 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29136 if (SWIG_arg_fail(2)) SWIG_fail;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 {
29146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29147 }
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj;
29156 wxWindow *arg1 = (wxWindow *) 0 ;
29157 wxBackgroundStyle result;
29158 PyObject * obj0 = 0 ;
29159 char *kwnames[] = {
29160 (char *) "self", NULL
29161 };
29162
29163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29165 if (SWIG_arg_fail(1)) SWIG_fail;
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29169
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 resultobj = SWIG_From_int((result));
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29181 PyObject *resultobj;
29182 wxWindow *arg1 = (wxWindow *) 0 ;
29183 wxCursor *arg2 = 0 ;
29184 bool result;
29185 PyObject * obj0 = 0 ;
29186 PyObject * obj1 = 0 ;
29187 char *kwnames[] = {
29188 (char *) "self",(char *) "cursor", NULL
29189 };
29190
29191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29193 if (SWIG_arg_fail(1)) SWIG_fail;
29194 {
29195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29196 if (SWIG_arg_fail(2)) SWIG_fail;
29197 if (arg2 == NULL) {
29198 SWIG_null_ref("wxCursor");
29199 }
29200 if (SWIG_arg_fail(2)) SWIG_fail;
29201 }
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29205
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 {
29210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29211 }
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj;
29220 wxWindow *arg1 = (wxWindow *) 0 ;
29221 wxCursor result;
29222 PyObject * obj0 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "self", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29232 result = (arg1)->GetCursor();
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 {
29238 wxCursor * resultptr;
29239 resultptr = new wxCursor((wxCursor &)(result));
29240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29241 }
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29249 PyObject *resultobj;
29250 wxWindow *arg1 = (wxWindow *) 0 ;
29251 wxFont *arg2 = 0 ;
29252 bool result;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 char *kwnames[] = {
29256 (char *) "self",(char *) "font", NULL
29257 };
29258
29259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(1)) SWIG_fail;
29262 {
29263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29264 if (SWIG_arg_fail(2)) SWIG_fail;
29265 if (arg2 == NULL) {
29266 SWIG_null_ref("wxFont");
29267 }
29268 if (SWIG_arg_fail(2)) SWIG_fail;
29269 }
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29273
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 {
29278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29279 }
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj;
29288 wxWindow *arg1 = (wxWindow *) 0 ;
29289 wxFont *arg2 = 0 ;
29290 PyObject * obj0 = 0 ;
29291 PyObject * obj1 = 0 ;
29292 char *kwnames[] = {
29293 (char *) "self",(char *) "font", NULL
29294 };
29295
29296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29298 if (SWIG_arg_fail(1)) SWIG_fail;
29299 {
29300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29301 if (SWIG_arg_fail(2)) SWIG_fail;
29302 if (arg2 == NULL) {
29303 SWIG_null_ref("wxFont");
29304 }
29305 if (SWIG_arg_fail(2)) SWIG_fail;
29306 }
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 (arg1)->SetOwnFont((wxFont const &)*arg2);
29310
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 Py_INCREF(Py_None); resultobj = Py_None;
29315 return resultobj;
29316 fail:
29317 return NULL;
29318 }
29319
29320
29321 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29322 PyObject *resultobj;
29323 wxWindow *arg1 = (wxWindow *) 0 ;
29324 wxFont result;
29325 PyObject * obj0 = 0 ;
29326 char *kwnames[] = {
29327 (char *) "self", NULL
29328 };
29329
29330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29332 if (SWIG_arg_fail(1)) SWIG_fail;
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 result = (arg1)->GetFont();
29336
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 {
29341 wxFont * resultptr;
29342 resultptr = new wxFont((wxFont &)(result));
29343 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29344 }
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj;
29353 wxWindow *arg1 = (wxWindow *) 0 ;
29354 wxCaret *arg2 = (wxCaret *) 0 ;
29355 PyObject * obj0 = 0 ;
29356 PyObject * obj1 = 0 ;
29357 char *kwnames[] = {
29358 (char *) "self",(char *) "caret", NULL
29359 };
29360
29361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29363 if (SWIG_arg_fail(1)) SWIG_fail;
29364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(2)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 (arg1)->SetCaret(arg2);
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 Py_INCREF(Py_None); resultobj = Py_None;
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj;
29382 wxWindow *arg1 = (wxWindow *) 0 ;
29383 wxCaret *result;
29384 PyObject * obj0 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 int result;
29410 PyObject * obj0 = 0 ;
29411 char *kwnames[] = {
29412 (char *) "self", NULL
29413 };
29414
29415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29417 if (SWIG_arg_fail(1)) SWIG_fail;
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29421
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 {
29426 resultobj = SWIG_From_int((int)(result));
29427 }
29428 return resultobj;
29429 fail:
29430 return NULL;
29431 }
29432
29433
29434 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29435 PyObject *resultobj;
29436 wxWindow *arg1 = (wxWindow *) 0 ;
29437 int result;
29438 PyObject * obj0 = 0 ;
29439 char *kwnames[] = {
29440 (char *) "self", NULL
29441 };
29442
29443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29445 if (SWIG_arg_fail(1)) SWIG_fail;
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29449
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 {
29454 resultobj = SWIG_From_int((int)(result));
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 wxString *arg2 = 0 ;
29466 int *arg3 = (int *) 0 ;
29467 int *arg4 = (int *) 0 ;
29468 bool temp2 = false ;
29469 int temp3 ;
29470 int res3 = 0 ;
29471 int temp4 ;
29472 int res4 = 0 ;
29473 PyObject * obj0 = 0 ;
29474 PyObject * obj1 = 0 ;
29475 char *kwnames[] = {
29476 (char *) "self",(char *) "string", NULL
29477 };
29478
29479 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29480 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29483 if (SWIG_arg_fail(1)) SWIG_fail;
29484 {
29485 arg2 = wxString_in_helper(obj1);
29486 if (arg2 == NULL) SWIG_fail;
29487 temp2 = true;
29488 }
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29492
29493 wxPyEndAllowThreads(__tstate);
29494 if (PyErr_Occurred()) SWIG_fail;
29495 }
29496 Py_INCREF(Py_None); resultobj = Py_None;
29497 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29498 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29499 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29500 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29501 {
29502 if (temp2)
29503 delete arg2;
29504 }
29505 return resultobj;
29506 fail:
29507 {
29508 if (temp2)
29509 delete arg2;
29510 }
29511 return NULL;
29512 }
29513
29514
29515 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj;
29517 wxWindow *arg1 = (wxWindow *) 0 ;
29518 wxString *arg2 = 0 ;
29519 int *arg3 = (int *) 0 ;
29520 int *arg4 = (int *) 0 ;
29521 int *arg5 = (int *) 0 ;
29522 int *arg6 = (int *) 0 ;
29523 wxFont *arg7 = (wxFont *) NULL ;
29524 bool temp2 = false ;
29525 int temp3 ;
29526 int res3 = 0 ;
29527 int temp4 ;
29528 int res4 = 0 ;
29529 int temp5 ;
29530 int res5 = 0 ;
29531 int temp6 ;
29532 int res6 = 0 ;
29533 PyObject * obj0 = 0 ;
29534 PyObject * obj1 = 0 ;
29535 PyObject * obj2 = 0 ;
29536 char *kwnames[] = {
29537 (char *) "self",(char *) "string",(char *) "font", NULL
29538 };
29539
29540 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29541 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29542 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29543 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29546 if (SWIG_arg_fail(1)) SWIG_fail;
29547 {
29548 arg2 = wxString_in_helper(obj1);
29549 if (arg2 == NULL) SWIG_fail;
29550 temp2 = true;
29551 }
29552 if (obj2) {
29553 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29554 if (SWIG_arg_fail(7)) SWIG_fail;
29555 }
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29559
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 Py_INCREF(Py_None); resultobj = Py_None;
29564 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29565 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29566 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29567 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29568 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29569 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29570 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29571 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29572 {
29573 if (temp2)
29574 delete arg2;
29575 }
29576 return resultobj;
29577 fail:
29578 {
29579 if (temp2)
29580 delete arg2;
29581 }
29582 return NULL;
29583 }
29584
29585
29586 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29587 PyObject *resultobj;
29588 wxWindow *arg1 = (wxWindow *) 0 ;
29589 int *arg2 = (int *) 0 ;
29590 int *arg3 = (int *) 0 ;
29591 int temp2 ;
29592 int res2 = 0 ;
29593 int temp3 ;
29594 int res3 = 0 ;
29595 PyObject * obj0 = 0 ;
29596 PyObject * obj1 = 0 ;
29597 PyObject * obj2 = 0 ;
29598 char *kwnames[] = {
29599 (char *) "self",(char *) "x",(char *) "y", NULL
29600 };
29601
29602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29604 if (SWIG_arg_fail(1)) SWIG_fail;
29605 {
29606 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29607 temp2 = SWIG_As_int(obj1);
29608 if (SWIG_arg_fail(2)) SWIG_fail;
29609 arg2 = &temp2;
29610 res2 = SWIG_NEWOBJ;
29611 }
29612 }
29613 {
29614 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29615 temp3 = SWIG_As_int(obj2);
29616 if (SWIG_arg_fail(3)) SWIG_fail;
29617 arg3 = &temp3;
29618 res3 = SWIG_NEWOBJ;
29619 }
29620 }
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29624
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 Py_INCREF(Py_None); resultobj = Py_None;
29629 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29630 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29631 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29632 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29633 return resultobj;
29634 fail:
29635 return NULL;
29636 }
29637
29638
29639 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29640 PyObject *resultobj;
29641 wxWindow *arg1 = (wxWindow *) 0 ;
29642 int *arg2 = (int *) 0 ;
29643 int *arg3 = (int *) 0 ;
29644 int temp2 ;
29645 int res2 = 0 ;
29646 int temp3 ;
29647 int res3 = 0 ;
29648 PyObject * obj0 = 0 ;
29649 PyObject * obj1 = 0 ;
29650 PyObject * obj2 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self",(char *) "x",(char *) "y", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29660 temp2 = SWIG_As_int(obj1);
29661 if (SWIG_arg_fail(2)) SWIG_fail;
29662 arg2 = &temp2;
29663 res2 = SWIG_NEWOBJ;
29664 }
29665 }
29666 {
29667 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29668 temp3 = SWIG_As_int(obj2);
29669 if (SWIG_arg_fail(3)) SWIG_fail;
29670 arg3 = &temp3;
29671 res3 = SWIG_NEWOBJ;
29672 }
29673 }
29674 {
29675 PyThreadState* __tstate = wxPyBeginAllowThreads();
29676 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29677
29678 wxPyEndAllowThreads(__tstate);
29679 if (PyErr_Occurred()) SWIG_fail;
29680 }
29681 Py_INCREF(Py_None); resultobj = Py_None;
29682 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29683 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29684 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29685 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxWindow *arg1 = (wxWindow *) 0 ;
29695 wxPoint *arg2 = 0 ;
29696 wxPoint result;
29697 wxPoint temp2 ;
29698 PyObject * obj0 = 0 ;
29699 PyObject * obj1 = 0 ;
29700 char *kwnames[] = {
29701 (char *) "self",(char *) "pt", NULL
29702 };
29703
29704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29706 if (SWIG_arg_fail(1)) SWIG_fail;
29707 {
29708 arg2 = &temp2;
29709 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29710 }
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 wxPoint * resultptr;
29720 resultptr = new wxPoint((wxPoint &)(result));
29721 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29722 }
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj;
29731 wxWindow *arg1 = (wxWindow *) 0 ;
29732 wxPoint *arg2 = 0 ;
29733 wxPoint result;
29734 wxPoint temp2 ;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 char *kwnames[] = {
29738 (char *) "self",(char *) "pt", NULL
29739 };
29740
29741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29743 if (SWIG_arg_fail(1)) SWIG_fail;
29744 {
29745 arg2 = &temp2;
29746 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29747 }
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29751
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 {
29756 wxPoint * resultptr;
29757 resultptr = new wxPoint((wxPoint &)(result));
29758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29759 }
29760 return resultobj;
29761 fail:
29762 return NULL;
29763 }
29764
29765
29766 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29767 PyObject *resultobj;
29768 wxWindow *arg1 = (wxWindow *) 0 ;
29769 int arg2 ;
29770 int arg3 ;
29771 wxHitTest result;
29772 PyObject * obj0 = 0 ;
29773 PyObject * obj1 = 0 ;
29774 PyObject * obj2 = 0 ;
29775 char *kwnames[] = {
29776 (char *) "self",(char *) "x",(char *) "y", NULL
29777 };
29778
29779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29781 if (SWIG_arg_fail(1)) SWIG_fail;
29782 {
29783 arg2 = (int)(SWIG_As_int(obj1));
29784 if (SWIG_arg_fail(2)) SWIG_fail;
29785 }
29786 {
29787 arg3 = (int)(SWIG_As_int(obj2));
29788 if (SWIG_arg_fail(3)) SWIG_fail;
29789 }
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29793
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 resultobj = SWIG_From_int((result));
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj;
29806 wxWindow *arg1 = (wxWindow *) 0 ;
29807 wxPoint *arg2 = 0 ;
29808 wxHitTest result;
29809 wxPoint temp2 ;
29810 PyObject * obj0 = 0 ;
29811 PyObject * obj1 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "pt", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 {
29820 arg2 = &temp2;
29821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29822 }
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29826
29827 wxPyEndAllowThreads(__tstate);
29828 if (PyErr_Occurred()) SWIG_fail;
29829 }
29830 resultobj = SWIG_From_int((result));
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29838 PyObject *resultobj;
29839 wxWindow *arg1 = (wxWindow *) 0 ;
29840 long arg2 ;
29841 wxBorder result;
29842 PyObject * obj0 = 0 ;
29843 PyObject * obj1 = 0 ;
29844
29845 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29847 if (SWIG_arg_fail(1)) SWIG_fail;
29848 {
29849 arg2 = (long)(SWIG_As_long(obj1));
29850 if (SWIG_arg_fail(2)) SWIG_fail;
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_From_int((result));
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29867 PyObject *resultobj;
29868 wxWindow *arg1 = (wxWindow *) 0 ;
29869 wxBorder result;
29870 PyObject * obj0 = 0 ;
29871
29872 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29874 if (SWIG_arg_fail(1)) SWIG_fail;
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 resultobj = SWIG_From_int((result));
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29890 int argc;
29891 PyObject *argv[3];
29892 int ii;
29893
29894 argc = PyObject_Length(args);
29895 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29896 argv[ii] = PyTuple_GetItem(args,ii);
29897 }
29898 if (argc == 1) {
29899 int _v;
29900 {
29901 void *ptr;
29902 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29903 _v = 0;
29904 PyErr_Clear();
29905 } else {
29906 _v = 1;
29907 }
29908 }
29909 if (_v) {
29910 return _wrap_Window_GetBorder__SWIG_1(self,args);
29911 }
29912 }
29913 if (argc == 2) {
29914 int _v;
29915 {
29916 void *ptr;
29917 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29918 _v = 0;
29919 PyErr_Clear();
29920 } else {
29921 _v = 1;
29922 }
29923 }
29924 if (_v) {
29925 _v = SWIG_Check_long(argv[1]);
29926 if (_v) {
29927 return _wrap_Window_GetBorder__SWIG_0(self,args);
29928 }
29929 }
29930 }
29931
29932 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 long arg2 = (long) wxUPDATE_UI_NONE ;
29941 PyObject * obj0 = 0 ;
29942 PyObject * obj1 = 0 ;
29943 char *kwnames[] = {
29944 (char *) "self",(char *) "flags", NULL
29945 };
29946
29947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29949 if (SWIG_arg_fail(1)) SWIG_fail;
29950 if (obj1) {
29951 {
29952 arg2 = (long)(SWIG_As_long(obj1));
29953 if (SWIG_arg_fail(2)) SWIG_fail;
29954 }
29955 }
29956 {
29957 PyThreadState* __tstate = wxPyBeginAllowThreads();
29958 (arg1)->UpdateWindowUI(arg2);
29959
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 Py_INCREF(Py_None); resultobj = Py_None;
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj;
29972 wxWindow *arg1 = (wxWindow *) 0 ;
29973 wxMenu *arg2 = (wxMenu *) 0 ;
29974 int arg3 = (int) -1 ;
29975 int arg4 = (int) -1 ;
29976 bool result;
29977 PyObject * obj0 = 0 ;
29978 PyObject * obj1 = 0 ;
29979 PyObject * obj2 = 0 ;
29980 PyObject * obj3 = 0 ;
29981 char *kwnames[] = {
29982 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29983 };
29984
29985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29987 if (SWIG_arg_fail(1)) SWIG_fail;
29988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(2)) SWIG_fail;
29990 if (obj2) {
29991 {
29992 arg3 = (int)(SWIG_As_int(obj2));
29993 if (SWIG_arg_fail(3)) SWIG_fail;
29994 }
29995 }
29996 if (obj3) {
29997 {
29998 arg4 = (int)(SWIG_As_int(obj3));
29999 if (SWIG_arg_fail(4)) SWIG_fail;
30000 }
30001 }
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj;
30020 wxWindow *arg1 = (wxWindow *) 0 ;
30021 wxMenu *arg2 = (wxMenu *) 0 ;
30022 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30023 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30024 bool result;
30025 wxPoint temp3 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 char *kwnames[] = {
30030 (char *) "self",(char *) "menu",(char *) "pos", NULL
30031 };
30032
30033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30035 if (SWIG_arg_fail(1)) SWIG_fail;
30036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30037 if (SWIG_arg_fail(2)) SWIG_fail;
30038 if (obj2) {
30039 {
30040 arg3 = &temp3;
30041 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30042 }
30043 }
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30047
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 {
30052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30053 }
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj;
30062 wxWindow *arg1 = (wxWindow *) 0 ;
30063 long result;
30064 PyObject * obj0 = 0 ;
30065 char *kwnames[] = {
30066 (char *) "self", NULL
30067 };
30068
30069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30071 if (SWIG_arg_fail(1)) SWIG_fail;
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (long)wxWindow_GetHandle(arg1);
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = SWIG_From_long((long)(result));
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 long arg2 ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 char *kwnames[] = {
30095 (char *) "self",(char *) "handle", NULL
30096 };
30097
30098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30100 if (SWIG_arg_fail(1)) SWIG_fail;
30101 {
30102 arg2 = (long)(SWIG_As_long(obj1));
30103 if (SWIG_arg_fail(2)) SWIG_fail;
30104 }
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 wxWindow_AssociateHandle(arg1,arg2);
30108
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 Py_INCREF(Py_None); resultobj = Py_None;
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 PyObject * obj0 = 0 ;
30123 char *kwnames[] = {
30124 (char *) "self", NULL
30125 };
30126
30127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30129 if (SWIG_arg_fail(1)) SWIG_fail;
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 (arg1)->DissociateHandle();
30133
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 Py_INCREF(Py_None); resultobj = Py_None;
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30145 PyObject *resultobj;
30146 wxWindow *arg1 = (wxWindow *) 0 ;
30147 int arg2 ;
30148 bool result;
30149 PyObject * obj0 = 0 ;
30150 PyObject * obj1 = 0 ;
30151 char *kwnames[] = {
30152 (char *) "self",(char *) "orient", NULL
30153 };
30154
30155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
30160 if (SWIG_arg_fail(2)) SWIG_fail;
30161 }
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30165
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 {
30170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30171 }
30172 return resultobj;
30173 fail:
30174 return NULL;
30175 }
30176
30177
30178 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30179 PyObject *resultobj;
30180 wxWindow *arg1 = (wxWindow *) 0 ;
30181 int arg2 ;
30182 int arg3 ;
30183 int arg4 ;
30184 int arg5 ;
30185 bool arg6 = (bool) true ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 PyObject * obj2 = 0 ;
30189 PyObject * obj3 = 0 ;
30190 PyObject * obj4 = 0 ;
30191 PyObject * obj5 = 0 ;
30192 char *kwnames[] = {
30193 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30194 };
30195
30196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30198 if (SWIG_arg_fail(1)) SWIG_fail;
30199 {
30200 arg2 = (int)(SWIG_As_int(obj1));
30201 if (SWIG_arg_fail(2)) SWIG_fail;
30202 }
30203 {
30204 arg3 = (int)(SWIG_As_int(obj2));
30205 if (SWIG_arg_fail(3)) SWIG_fail;
30206 }
30207 {
30208 arg4 = (int)(SWIG_As_int(obj3));
30209 if (SWIG_arg_fail(4)) SWIG_fail;
30210 }
30211 {
30212 arg5 = (int)(SWIG_As_int(obj4));
30213 if (SWIG_arg_fail(5)) SWIG_fail;
30214 }
30215 if (obj5) {
30216 {
30217 arg6 = (bool)(SWIG_As_bool(obj5));
30218 if (SWIG_arg_fail(6)) SWIG_fail;
30219 }
30220 }
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30224
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 Py_INCREF(Py_None); resultobj = Py_None;
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj;
30237 wxWindow *arg1 = (wxWindow *) 0 ;
30238 int arg2 ;
30239 int arg3 ;
30240 bool arg4 = (bool) true ;
30241 PyObject * obj0 = 0 ;
30242 PyObject * obj1 = 0 ;
30243 PyObject * obj2 = 0 ;
30244 PyObject * obj3 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 {
30253 arg2 = (int)(SWIG_As_int(obj1));
30254 if (SWIG_arg_fail(2)) SWIG_fail;
30255 }
30256 {
30257 arg3 = (int)(SWIG_As_int(obj2));
30258 if (SWIG_arg_fail(3)) SWIG_fail;
30259 }
30260 if (obj3) {
30261 {
30262 arg4 = (bool)(SWIG_As_bool(obj3));
30263 if (SWIG_arg_fail(4)) SWIG_fail;
30264 }
30265 }
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 (arg1)->SetScrollPos(arg2,arg3,arg4);
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 Py_INCREF(Py_None); resultobj = Py_None;
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj;
30282 wxWindow *arg1 = (wxWindow *) 0 ;
30283 int arg2 ;
30284 int result;
30285 PyObject * obj0 = 0 ;
30286 PyObject * obj1 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "orientation", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 {
30295 arg2 = (int)(SWIG_As_int(obj1));
30296 if (SWIG_arg_fail(2)) SWIG_fail;
30297 }
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30301
30302 wxPyEndAllowThreads(__tstate);
30303 if (PyErr_Occurred()) SWIG_fail;
30304 }
30305 {
30306 resultobj = SWIG_From_int((int)(result));
30307 }
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30315 PyObject *resultobj;
30316 wxWindow *arg1 = (wxWindow *) 0 ;
30317 int arg2 ;
30318 int result;
30319 PyObject * obj0 = 0 ;
30320 PyObject * obj1 = 0 ;
30321 char *kwnames[] = {
30322 (char *) "self",(char *) "orientation", NULL
30323 };
30324
30325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30327 if (SWIG_arg_fail(1)) SWIG_fail;
30328 {
30329 arg2 = (int)(SWIG_As_int(obj1));
30330 if (SWIG_arg_fail(2)) SWIG_fail;
30331 }
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30335
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 {
30340 resultobj = SWIG_From_int((int)(result));
30341 }
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 int arg2 ;
30352 int result;
30353 PyObject * obj0 = 0 ;
30354 PyObject * obj1 = 0 ;
30355 char *kwnames[] = {
30356 (char *) "self",(char *) "orientation", NULL
30357 };
30358
30359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30361 if (SWIG_arg_fail(1)) SWIG_fail;
30362 {
30363 arg2 = (int)(SWIG_As_int(obj1));
30364 if (SWIG_arg_fail(2)) SWIG_fail;
30365 }
30366 {
30367 PyThreadState* __tstate = wxPyBeginAllowThreads();
30368 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30369
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 {
30374 resultobj = SWIG_From_int((int)(result));
30375 }
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30383 PyObject *resultobj;
30384 wxWindow *arg1 = (wxWindow *) 0 ;
30385 int arg2 ;
30386 int arg3 ;
30387 wxRect *arg4 = (wxRect *) NULL ;
30388 PyObject * obj0 = 0 ;
30389 PyObject * obj1 = 0 ;
30390 PyObject * obj2 = 0 ;
30391 PyObject * obj3 = 0 ;
30392 char *kwnames[] = {
30393 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30394 };
30395
30396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30398 if (SWIG_arg_fail(1)) SWIG_fail;
30399 {
30400 arg2 = (int)(SWIG_As_int(obj1));
30401 if (SWIG_arg_fail(2)) SWIG_fail;
30402 }
30403 {
30404 arg3 = (int)(SWIG_As_int(obj2));
30405 if (SWIG_arg_fail(3)) SWIG_fail;
30406 }
30407 if (obj3) {
30408 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30409 if (SWIG_arg_fail(4)) SWIG_fail;
30410 }
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30414
30415 wxPyEndAllowThreads(__tstate);
30416 if (PyErr_Occurred()) SWIG_fail;
30417 }
30418 Py_INCREF(Py_None); resultobj = Py_None;
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30426 PyObject *resultobj;
30427 wxWindow *arg1 = (wxWindow *) 0 ;
30428 int arg2 ;
30429 bool result;
30430 PyObject * obj0 = 0 ;
30431 PyObject * obj1 = 0 ;
30432 char *kwnames[] = {
30433 (char *) "self",(char *) "lines", NULL
30434 };
30435
30436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30438 if (SWIG_arg_fail(1)) SWIG_fail;
30439 {
30440 arg2 = (int)(SWIG_As_int(obj1));
30441 if (SWIG_arg_fail(2)) SWIG_fail;
30442 }
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (bool)(arg1)->ScrollLines(arg2);
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxWindow *arg1 = (wxWindow *) 0 ;
30462 int arg2 ;
30463 bool result;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 char *kwnames[] = {
30467 (char *) "self",(char *) "pages", NULL
30468 };
30469
30470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30472 if (SWIG_arg_fail(1)) SWIG_fail;
30473 {
30474 arg2 = (int)(SWIG_As_int(obj1));
30475 if (SWIG_arg_fail(2)) SWIG_fail;
30476 }
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = (bool)(arg1)->ScrollPages(arg2);
30480
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 {
30485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30486 }
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 bool result;
30497 PyObject * obj0 = 0 ;
30498 char *kwnames[] = {
30499 (char *) "self", NULL
30500 };
30501
30502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30504 if (SWIG_arg_fail(1)) SWIG_fail;
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 result = (bool)(arg1)->LineUp();
30508
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 {
30513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30514 }
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 bool result;
30525 PyObject * obj0 = 0 ;
30526 char *kwnames[] = {
30527 (char *) "self", NULL
30528 };
30529
30530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30532 if (SWIG_arg_fail(1)) SWIG_fail;
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = (bool)(arg1)->LineDown();
30536
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 bool result;
30553 PyObject * obj0 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (bool)(arg1)->PageUp();
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 {
30569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30570 }
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj;
30579 wxWindow *arg1 = (wxWindow *) 0 ;
30580 bool result;
30581 PyObject * obj0 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 result = (bool)(arg1)->PageDown();
30592
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 {
30597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30598 }
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 wxWindow *arg1 = (wxWindow *) 0 ;
30608 wxString *arg2 = 0 ;
30609 bool temp2 = false ;
30610 PyObject * obj0 = 0 ;
30611 PyObject * obj1 = 0 ;
30612 char *kwnames[] = {
30613 (char *) "self",(char *) "text", NULL
30614 };
30615
30616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30618 if (SWIG_arg_fail(1)) SWIG_fail;
30619 {
30620 arg2 = wxString_in_helper(obj1);
30621 if (arg2 == NULL) SWIG_fail;
30622 temp2 = true;
30623 }
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 (arg1)->SetHelpText((wxString const &)*arg2);
30627
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 Py_INCREF(Py_None); resultobj = Py_None;
30632 {
30633 if (temp2)
30634 delete arg2;
30635 }
30636 return resultobj;
30637 fail:
30638 {
30639 if (temp2)
30640 delete arg2;
30641 }
30642 return NULL;
30643 }
30644
30645
30646 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj;
30648 wxWindow *arg1 = (wxWindow *) 0 ;
30649 wxString *arg2 = 0 ;
30650 bool temp2 = false ;
30651 PyObject * obj0 = 0 ;
30652 PyObject * obj1 = 0 ;
30653 char *kwnames[] = {
30654 (char *) "self",(char *) "text", NULL
30655 };
30656
30657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30659 if (SWIG_arg_fail(1)) SWIG_fail;
30660 {
30661 arg2 = wxString_in_helper(obj1);
30662 if (arg2 == NULL) SWIG_fail;
30663 temp2 = true;
30664 }
30665 {
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30668
30669 wxPyEndAllowThreads(__tstate);
30670 if (PyErr_Occurred()) SWIG_fail;
30671 }
30672 Py_INCREF(Py_None); resultobj = Py_None;
30673 {
30674 if (temp2)
30675 delete arg2;
30676 }
30677 return resultobj;
30678 fail:
30679 {
30680 if (temp2)
30681 delete arg2;
30682 }
30683 return NULL;
30684 }
30685
30686
30687 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj;
30689 wxWindow *arg1 = (wxWindow *) 0 ;
30690 wxString result;
30691 PyObject * obj0 = 0 ;
30692 char *kwnames[] = {
30693 (char *) "self", NULL
30694 };
30695
30696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30698 if (SWIG_arg_fail(1)) SWIG_fail;
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 result = ((wxWindow const *)arg1)->GetHelpText();
30702
30703 wxPyEndAllowThreads(__tstate);
30704 if (PyErr_Occurred()) SWIG_fail;
30705 }
30706 {
30707 #if wxUSE_UNICODE
30708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30709 #else
30710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30711 #endif
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 wxString *arg2 = 0 ;
30723 bool temp2 = false ;
30724 PyObject * obj0 = 0 ;
30725 PyObject * obj1 = 0 ;
30726 char *kwnames[] = {
30727 (char *) "self",(char *) "tip", NULL
30728 };
30729
30730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30732 if (SWIG_arg_fail(1)) SWIG_fail;
30733 {
30734 arg2 = wxString_in_helper(obj1);
30735 if (arg2 == NULL) SWIG_fail;
30736 temp2 = true;
30737 }
30738 {
30739 PyThreadState* __tstate = wxPyBeginAllowThreads();
30740 (arg1)->SetToolTip((wxString const &)*arg2);
30741
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 Py_INCREF(Py_None); resultobj = Py_None;
30746 {
30747 if (temp2)
30748 delete arg2;
30749 }
30750 return resultobj;
30751 fail:
30752 {
30753 if (temp2)
30754 delete arg2;
30755 }
30756 return NULL;
30757 }
30758
30759
30760 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30761 PyObject *resultobj;
30762 wxWindow *arg1 = (wxWindow *) 0 ;
30763 wxToolTip *arg2 = (wxToolTip *) 0 ;
30764 PyObject * obj0 = 0 ;
30765 PyObject * obj1 = 0 ;
30766 char *kwnames[] = {
30767 (char *) "self",(char *) "tip", NULL
30768 };
30769
30770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30772 if (SWIG_arg_fail(1)) SWIG_fail;
30773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30774 if (SWIG_arg_fail(2)) SWIG_fail;
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 (arg1)->SetToolTip(arg2);
30778
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 Py_INCREF(Py_None); resultobj = Py_None;
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxToolTip *result;
30793 PyObject * obj0 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 {
30809 resultobj = wxPyMake_wxObject(result, 0);
30810 }
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30821 PyObject * obj0 = 0 ;
30822 PyObject * obj1 = 0 ;
30823 char *kwnames[] = {
30824 (char *) "self",(char *) "dropTarget", NULL
30825 };
30826
30827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30829 if (SWIG_arg_fail(1)) SWIG_fail;
30830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30831 if (SWIG_arg_fail(2)) SWIG_fail;
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 (arg1)->SetDropTarget(arg2);
30835
30836 wxPyEndAllowThreads(__tstate);
30837 if (PyErr_Occurred()) SWIG_fail;
30838 }
30839 Py_INCREF(Py_None); resultobj = Py_None;
30840 return resultobj;
30841 fail:
30842 return NULL;
30843 }
30844
30845
30846 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30847 PyObject *resultobj;
30848 wxWindow *arg1 = (wxWindow *) 0 ;
30849 wxPyDropTarget *result;
30850 PyObject * obj0 = 0 ;
30851 char *kwnames[] = {
30852 (char *) "self", NULL
30853 };
30854
30855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30857 if (SWIG_arg_fail(1)) SWIG_fail;
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30861
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxWindow *arg1 = (wxWindow *) 0 ;
30875 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30876 PyObject * obj0 = 0 ;
30877 PyObject * obj1 = 0 ;
30878 char *kwnames[] = {
30879 (char *) "self",(char *) "constraints", NULL
30880 };
30881
30882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30884 if (SWIG_arg_fail(1)) SWIG_fail;
30885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30886 if (SWIG_arg_fail(2)) SWIG_fail;
30887 {
30888 PyThreadState* __tstate = wxPyBeginAllowThreads();
30889 (arg1)->SetConstraints(arg2);
30890
30891 wxPyEndAllowThreads(__tstate);
30892 if (PyErr_Occurred()) SWIG_fail;
30893 }
30894 Py_INCREF(Py_None); resultobj = Py_None;
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj;
30903 wxWindow *arg1 = (wxWindow *) 0 ;
30904 wxLayoutConstraints *result;
30905 PyObject * obj0 = 0 ;
30906 char *kwnames[] = {
30907 (char *) "self", NULL
30908 };
30909
30910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30912 if (SWIG_arg_fail(1)) SWIG_fail;
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 bool arg2 ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self",(char *) "autoLayout", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 arg2 = (bool)(SWIG_As_bool(obj1));
30942 if (SWIG_arg_fail(2)) SWIG_fail;
30943 }
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 (arg1)->SetAutoLayout(arg2);
30947
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 Py_INCREF(Py_None); resultobj = Py_None;
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj;
30960 wxWindow *arg1 = (wxWindow *) 0 ;
30961 bool result;
30962 PyObject * obj0 = 0 ;
30963 char *kwnames[] = {
30964 (char *) "self", NULL
30965 };
30966
30967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
30968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(1)) SWIG_fail;
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
30973
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 {
30978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30979 }
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
30987 PyObject *resultobj;
30988 wxWindow *arg1 = (wxWindow *) 0 ;
30989 bool result;
30990 PyObject * obj0 = 0 ;
30991 char *kwnames[] = {
30992 (char *) "self", NULL
30993 };
30994
30995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
30996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30997 if (SWIG_arg_fail(1)) SWIG_fail;
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 result = (bool)(arg1)->Layout();
31001
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 {
31006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxSizer *arg2 = (wxSizer *) 0 ;
31018 bool arg3 = (bool) true ;
31019 PyObject * obj0 = 0 ;
31020 PyObject * obj1 = 0 ;
31021 PyObject * obj2 = 0 ;
31022 char *kwnames[] = {
31023 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31024 };
31025
31026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31028 if (SWIG_arg_fail(1)) SWIG_fail;
31029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(2)) SWIG_fail;
31031 if (obj2) {
31032 {
31033 arg3 = (bool)(SWIG_As_bool(obj2));
31034 if (SWIG_arg_fail(3)) SWIG_fail;
31035 }
31036 }
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 (arg1)->SetSizer(arg2,arg3);
31040
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 Py_INCREF(Py_None); resultobj = Py_None;
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 wxSizer *arg2 = (wxSizer *) 0 ;
31055 bool arg3 = (bool) true ;
31056 PyObject * obj0 = 0 ;
31057 PyObject * obj1 = 0 ;
31058 PyObject * obj2 = 0 ;
31059 char *kwnames[] = {
31060 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31061 };
31062
31063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31065 if (SWIG_arg_fail(1)) SWIG_fail;
31066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(2)) SWIG_fail;
31068 if (obj2) {
31069 {
31070 arg3 = (bool)(SWIG_As_bool(obj2));
31071 if (SWIG_arg_fail(3)) SWIG_fail;
31072 }
31073 }
31074 {
31075 PyThreadState* __tstate = wxPyBeginAllowThreads();
31076 (arg1)->SetSizerAndFit(arg2,arg3);
31077
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 Py_INCREF(Py_None); resultobj = Py_None;
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31089 PyObject *resultobj;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxSizer *result;
31092 PyObject * obj0 = 0 ;
31093 char *kwnames[] = {
31094 (char *) "self", NULL
31095 };
31096
31097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31099 if (SWIG_arg_fail(1)) SWIG_fail;
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 {
31108 resultobj = wxPyMake_wxSizer(result, 0);
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSizer *arg2 = (wxSizer *) 0 ;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 char *kwnames[] = {
31123 (char *) "self",(char *) "sizer", NULL
31124 };
31125
31126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31128 if (SWIG_arg_fail(1)) SWIG_fail;
31129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31130 if (SWIG_arg_fail(2)) SWIG_fail;
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 (arg1)->SetContainingSizer(arg2);
31134
31135 wxPyEndAllowThreads(__tstate);
31136 if (PyErr_Occurred()) SWIG_fail;
31137 }
31138 Py_INCREF(Py_None); resultobj = Py_None;
31139 return resultobj;
31140 fail:
31141 return NULL;
31142 }
31143
31144
31145 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31146 PyObject *resultobj;
31147 wxWindow *arg1 = (wxWindow *) 0 ;
31148 wxSizer *result;
31149 PyObject * obj0 = 0 ;
31150 char *kwnames[] = {
31151 (char *) "self", NULL
31152 };
31153
31154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31156 if (SWIG_arg_fail(1)) SWIG_fail;
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31160
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 {
31165 resultobj = wxPyMake_wxSizer(result, 0);
31166 }
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj;
31175 wxWindow *arg1 = (wxWindow *) 0 ;
31176 PyObject * obj0 = 0 ;
31177 char *kwnames[] = {
31178 (char *) "self", NULL
31179 };
31180
31181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31183 if (SWIG_arg_fail(1)) SWIG_fail;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 (arg1)->InheritAttributes();
31187
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 Py_INCREF(Py_None); resultobj = Py_None;
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31199 PyObject *resultobj;
31200 wxWindow *arg1 = (wxWindow *) 0 ;
31201 bool result;
31202 PyObject * obj0 = 0 ;
31203 char *kwnames[] = {
31204 (char *) "self", NULL
31205 };
31206
31207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31209 if (SWIG_arg_fail(1)) SWIG_fail;
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31213
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 {
31218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31219 }
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31227 PyObject *obj;
31228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31229 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31230 Py_INCREF(obj);
31231 return Py_BuildValue((char *)"");
31232 }
31233 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31234 PyObject *resultobj;
31235 long arg1 ;
31236 wxWindow *arg2 = (wxWindow *) NULL ;
31237 wxWindow *result;
31238 PyObject * obj0 = 0 ;
31239 PyObject * obj1 = 0 ;
31240 char *kwnames[] = {
31241 (char *) "id",(char *) "parent", NULL
31242 };
31243
31244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31245 {
31246 arg1 = (long)(SWIG_As_long(obj0));
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 }
31249 if (obj1) {
31250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31251 if (SWIG_arg_fail(2)) SWIG_fail;
31252 }
31253 {
31254 if (!wxPyCheckForApp()) SWIG_fail;
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31257
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 {
31262 resultobj = wxPyMake_wxObject(result, 0);
31263 }
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj;
31272 wxString *arg1 = 0 ;
31273 wxWindow *arg2 = (wxWindow *) NULL ;
31274 wxWindow *result;
31275 bool temp1 = false ;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char *kwnames[] = {
31279 (char *) "name",(char *) "parent", NULL
31280 };
31281
31282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31283 {
31284 arg1 = wxString_in_helper(obj0);
31285 if (arg1 == NULL) SWIG_fail;
31286 temp1 = true;
31287 }
31288 if (obj1) {
31289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31290 if (SWIG_arg_fail(2)) SWIG_fail;
31291 }
31292 {
31293 if (!wxPyCheckForApp()) SWIG_fail;
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31296
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 {
31301 resultobj = wxPyMake_wxObject(result, 0);
31302 }
31303 {
31304 if (temp1)
31305 delete arg1;
31306 }
31307 return resultobj;
31308 fail:
31309 {
31310 if (temp1)
31311 delete arg1;
31312 }
31313 return NULL;
31314 }
31315
31316
31317 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31318 PyObject *resultobj;
31319 wxString *arg1 = 0 ;
31320 wxWindow *arg2 = (wxWindow *) NULL ;
31321 wxWindow *result;
31322 bool temp1 = false ;
31323 PyObject * obj0 = 0 ;
31324 PyObject * obj1 = 0 ;
31325 char *kwnames[] = {
31326 (char *) "label",(char *) "parent", NULL
31327 };
31328
31329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31330 {
31331 arg1 = wxString_in_helper(obj0);
31332 if (arg1 == NULL) SWIG_fail;
31333 temp1 = true;
31334 }
31335 if (obj1) {
31336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31337 if (SWIG_arg_fail(2)) SWIG_fail;
31338 }
31339 {
31340 if (!wxPyCheckForApp()) SWIG_fail;
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31343
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 {
31348 resultobj = wxPyMake_wxObject(result, 0);
31349 }
31350 {
31351 if (temp1)
31352 delete arg1;
31353 }
31354 return resultobj;
31355 fail:
31356 {
31357 if (temp1)
31358 delete arg1;
31359 }
31360 return NULL;
31361 }
31362
31363
31364 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj;
31366 wxWindow *arg1 = (wxWindow *) 0 ;
31367 unsigned long arg2 ;
31368 wxWindow *result;
31369 PyObject * obj0 = 0 ;
31370 PyObject * obj1 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "parent",(char *) "_hWnd", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31380 if (SWIG_arg_fail(2)) SWIG_fail;
31381 }
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31385
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = wxPyMake_wxObject(result, 0);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj;
31400 wxValidator *result;
31401 char *kwnames[] = {
31402 NULL
31403 };
31404
31405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (wxValidator *)new wxValidator();
31409
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj;
31422 wxValidator *arg1 = (wxValidator *) 0 ;
31423 wxValidator *result;
31424 PyObject * obj0 = 0 ;
31425 char *kwnames[] = {
31426 (char *) "self", NULL
31427 };
31428
31429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31431 if (SWIG_arg_fail(1)) SWIG_fail;
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 result = (wxValidator *)(arg1)->Clone();
31435
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 {
31440 resultobj = wxPyMake_wxObject(result, 0);
31441 }
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj;
31450 wxValidator *arg1 = (wxValidator *) 0 ;
31451 wxWindow *arg2 = (wxWindow *) 0 ;
31452 bool result;
31453 PyObject * obj0 = 0 ;
31454 PyObject * obj1 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self",(char *) "parent", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31463 if (SWIG_arg_fail(2)) SWIG_fail;
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 result = (bool)(arg1)->Validate(arg2);
31467
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 {
31472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31473 }
31474 return resultobj;
31475 fail:
31476 return NULL;
31477 }
31478
31479
31480 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31481 PyObject *resultobj;
31482 wxValidator *arg1 = (wxValidator *) 0 ;
31483 bool result;
31484 PyObject * obj0 = 0 ;
31485 char *kwnames[] = {
31486 (char *) "self", NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(1)) SWIG_fail;
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 result = (bool)(arg1)->TransferToWindow();
31495
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 {
31500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31501 }
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31509 PyObject *resultobj;
31510 wxValidator *arg1 = (wxValidator *) 0 ;
31511 bool result;
31512 PyObject * obj0 = 0 ;
31513 char *kwnames[] = {
31514 (char *) "self", NULL
31515 };
31516
31517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31519 if (SWIG_arg_fail(1)) SWIG_fail;
31520 {
31521 PyThreadState* __tstate = wxPyBeginAllowThreads();
31522 result = (bool)(arg1)->TransferFromWindow();
31523
31524 wxPyEndAllowThreads(__tstate);
31525 if (PyErr_Occurred()) SWIG_fail;
31526 }
31527 {
31528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31529 }
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj;
31538 wxValidator *arg1 = (wxValidator *) 0 ;
31539 wxWindow *result;
31540 PyObject * obj0 = 0 ;
31541 char *kwnames[] = {
31542 (char *) "self", NULL
31543 };
31544
31545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31547 if (SWIG_arg_fail(1)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = (wxWindow *)(arg1)->GetWindow();
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 {
31556 resultobj = wxPyMake_wxObject(result, 0);
31557 }
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31565 PyObject *resultobj;
31566 wxValidator *arg1 = (wxValidator *) 0 ;
31567 wxWindow *arg2 = (wxWindow *) 0 ;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 char *kwnames[] = {
31571 (char *) "self",(char *) "window", NULL
31572 };
31573
31574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31576 if (SWIG_arg_fail(1)) SWIG_fail;
31577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31578 if (SWIG_arg_fail(2)) SWIG_fail;
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 (arg1)->SetWindow(arg2);
31582
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 Py_INCREF(Py_None); resultobj = Py_None;
31587 return resultobj;
31588 fail:
31589 return NULL;
31590 }
31591
31592
31593 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31594 PyObject *resultobj;
31595 bool result;
31596 char *kwnames[] = {
31597 NULL
31598 };
31599
31600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31601 {
31602 PyThreadState* __tstate = wxPyBeginAllowThreads();
31603 result = (bool)wxValidator::IsSilent();
31604
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 {
31609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31610 }
31611 return resultobj;
31612 fail:
31613 return NULL;
31614 }
31615
31616
31617 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31618 PyObject *resultobj;
31619 int arg1 = (int) true ;
31620 PyObject * obj0 = 0 ;
31621 char *kwnames[] = {
31622 (char *) "doIt", NULL
31623 };
31624
31625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31626 if (obj0) {
31627 {
31628 arg1 = (int)(SWIG_As_int(obj0));
31629 if (SWIG_arg_fail(1)) SWIG_fail;
31630 }
31631 }
31632 {
31633 PyThreadState* __tstate = wxPyBeginAllowThreads();
31634 wxValidator::SetBellOnError(arg1);
31635
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 Py_INCREF(Py_None); resultobj = Py_None;
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31647 PyObject *obj;
31648 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31649 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31650 Py_INCREF(obj);
31651 return Py_BuildValue((char *)"");
31652 }
31653 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31654 PyObject *resultobj;
31655 wxPyValidator *result;
31656 char *kwnames[] = {
31657 NULL
31658 };
31659
31660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (wxPyValidator *)new wxPyValidator();
31664
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31676 PyObject *resultobj;
31677 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31678 PyObject *arg2 = (PyObject *) 0 ;
31679 PyObject *arg3 = (PyObject *) 0 ;
31680 int arg4 = (int) true ;
31681 PyObject * obj0 = 0 ;
31682 PyObject * obj1 = 0 ;
31683 PyObject * obj2 = 0 ;
31684 PyObject * obj3 = 0 ;
31685 char *kwnames[] = {
31686 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31687 };
31688
31689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31691 if (SWIG_arg_fail(1)) SWIG_fail;
31692 arg2 = obj1;
31693 arg3 = obj2;
31694 if (obj3) {
31695 {
31696 arg4 = (int)(SWIG_As_int(obj3));
31697 if (SWIG_arg_fail(4)) SWIG_fail;
31698 }
31699 }
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 Py_INCREF(Py_None); resultobj = Py_None;
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31715 PyObject *obj;
31716 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31717 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31718 Py_INCREF(obj);
31719 return Py_BuildValue((char *)"");
31720 }
31721 static int _wrap_DefaultValidator_set(PyObject *) {
31722 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31723 return 1;
31724 }
31725
31726
31727 static PyObject *_wrap_DefaultValidator_get(void) {
31728 PyObject *pyobj;
31729
31730 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31731 return pyobj;
31732 }
31733
31734
31735 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj;
31737 wxString const &arg1_defvalue = wxPyEmptyString ;
31738 wxString *arg1 = (wxString *) &arg1_defvalue ;
31739 long arg2 = (long) 0 ;
31740 wxMenu *result;
31741 bool temp1 = false ;
31742 PyObject * obj0 = 0 ;
31743 PyObject * obj1 = 0 ;
31744 char *kwnames[] = {
31745 (char *) "title",(char *) "style", NULL
31746 };
31747
31748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31749 if (obj0) {
31750 {
31751 arg1 = wxString_in_helper(obj0);
31752 if (arg1 == NULL) SWIG_fail;
31753 temp1 = true;
31754 }
31755 }
31756 if (obj1) {
31757 {
31758 arg2 = (long)(SWIG_As_long(obj1));
31759 if (SWIG_arg_fail(2)) SWIG_fail;
31760 }
31761 }
31762 {
31763 if (!wxPyCheckForApp()) SWIG_fail;
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31766
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31771 {
31772 if (temp1)
31773 delete arg1;
31774 }
31775 return resultobj;
31776 fail:
31777 {
31778 if (temp1)
31779 delete arg1;
31780 }
31781 return NULL;
31782 }
31783
31784
31785 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31786 PyObject *resultobj;
31787 wxMenu *arg1 = (wxMenu *) 0 ;
31788 int arg2 ;
31789 wxString *arg3 = 0 ;
31790 wxString const &arg4_defvalue = wxPyEmptyString ;
31791 wxString *arg4 = (wxString *) &arg4_defvalue ;
31792 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31793 wxMenuItem *result;
31794 bool temp3 = false ;
31795 bool temp4 = false ;
31796 PyObject * obj0 = 0 ;
31797 PyObject * obj1 = 0 ;
31798 PyObject * obj2 = 0 ;
31799 PyObject * obj3 = 0 ;
31800 PyObject * obj4 = 0 ;
31801 char *kwnames[] = {
31802 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31803 };
31804
31805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31807 if (SWIG_arg_fail(1)) SWIG_fail;
31808 {
31809 arg2 = (int)(SWIG_As_int(obj1));
31810 if (SWIG_arg_fail(2)) SWIG_fail;
31811 }
31812 {
31813 arg3 = wxString_in_helper(obj2);
31814 if (arg3 == NULL) SWIG_fail;
31815 temp3 = true;
31816 }
31817 if (obj3) {
31818 {
31819 arg4 = wxString_in_helper(obj3);
31820 if (arg4 == NULL) SWIG_fail;
31821 temp4 = true;
31822 }
31823 }
31824 if (obj4) {
31825 {
31826 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31827 if (SWIG_arg_fail(5)) SWIG_fail;
31828 }
31829 }
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31833
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 {
31838 resultobj = wxPyMake_wxObject(result, 0);
31839 }
31840 {
31841 if (temp3)
31842 delete arg3;
31843 }
31844 {
31845 if (temp4)
31846 delete arg4;
31847 }
31848 return resultobj;
31849 fail:
31850 {
31851 if (temp3)
31852 delete arg3;
31853 }
31854 {
31855 if (temp4)
31856 delete arg4;
31857 }
31858 return NULL;
31859 }
31860
31861
31862 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31863 PyObject *resultobj;
31864 wxMenu *arg1 = (wxMenu *) 0 ;
31865 wxMenuItem *result;
31866 PyObject * obj0 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (wxMenuItem *)(arg1)->AppendSeparator();
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = wxPyMake_wxObject(result, 0);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxMenu *arg1 = (wxMenu *) 0 ;
31893 int arg2 ;
31894 wxString *arg3 = 0 ;
31895 wxString const &arg4_defvalue = wxPyEmptyString ;
31896 wxString *arg4 = (wxString *) &arg4_defvalue ;
31897 wxMenuItem *result;
31898 bool temp3 = false ;
31899 bool temp4 = false ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 PyObject * obj2 = 0 ;
31903 PyObject * obj3 = 0 ;
31904 char *kwnames[] = {
31905 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31906 };
31907
31908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31910 if (SWIG_arg_fail(1)) SWIG_fail;
31911 {
31912 arg2 = (int)(SWIG_As_int(obj1));
31913 if (SWIG_arg_fail(2)) SWIG_fail;
31914 }
31915 {
31916 arg3 = wxString_in_helper(obj2);
31917 if (arg3 == NULL) SWIG_fail;
31918 temp3 = true;
31919 }
31920 if (obj3) {
31921 {
31922 arg4 = wxString_in_helper(obj3);
31923 if (arg4 == NULL) SWIG_fail;
31924 temp4 = true;
31925 }
31926 }
31927 {
31928 PyThreadState* __tstate = wxPyBeginAllowThreads();
31929 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31930
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 {
31935 resultobj = wxPyMake_wxObject(result, 0);
31936 }
31937 {
31938 if (temp3)
31939 delete arg3;
31940 }
31941 {
31942 if (temp4)
31943 delete arg4;
31944 }
31945 return resultobj;
31946 fail:
31947 {
31948 if (temp3)
31949 delete arg3;
31950 }
31951 {
31952 if (temp4)
31953 delete arg4;
31954 }
31955 return NULL;
31956 }
31957
31958
31959 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
31960 PyObject *resultobj;
31961 wxMenu *arg1 = (wxMenu *) 0 ;
31962 int arg2 ;
31963 wxString *arg3 = 0 ;
31964 wxString const &arg4_defvalue = wxPyEmptyString ;
31965 wxString *arg4 = (wxString *) &arg4_defvalue ;
31966 wxMenuItem *result;
31967 bool temp3 = false ;
31968 bool temp4 = false ;
31969 PyObject * obj0 = 0 ;
31970 PyObject * obj1 = 0 ;
31971 PyObject * obj2 = 0 ;
31972 PyObject * obj3 = 0 ;
31973 char *kwnames[] = {
31974 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31975 };
31976
31977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31979 if (SWIG_arg_fail(1)) SWIG_fail;
31980 {
31981 arg2 = (int)(SWIG_As_int(obj1));
31982 if (SWIG_arg_fail(2)) SWIG_fail;
31983 }
31984 {
31985 arg3 = wxString_in_helper(obj2);
31986 if (arg3 == NULL) SWIG_fail;
31987 temp3 = true;
31988 }
31989 if (obj3) {
31990 {
31991 arg4 = wxString_in_helper(obj3);
31992 if (arg4 == NULL) SWIG_fail;
31993 temp4 = true;
31994 }
31995 }
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31999
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 {
32004 resultobj = wxPyMake_wxObject(result, 0);
32005 }
32006 {
32007 if (temp3)
32008 delete arg3;
32009 }
32010 {
32011 if (temp4)
32012 delete arg4;
32013 }
32014 return resultobj;
32015 fail:
32016 {
32017 if (temp3)
32018 delete arg3;
32019 }
32020 {
32021 if (temp4)
32022 delete arg4;
32023 }
32024 return NULL;
32025 }
32026
32027
32028 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32029 PyObject *resultobj;
32030 wxMenu *arg1 = (wxMenu *) 0 ;
32031 int arg2 ;
32032 wxString *arg3 = 0 ;
32033 wxMenu *arg4 = (wxMenu *) 0 ;
32034 wxString const &arg5_defvalue = wxPyEmptyString ;
32035 wxString *arg5 = (wxString *) &arg5_defvalue ;
32036 wxMenuItem *result;
32037 bool temp3 = false ;
32038 bool temp5 = false ;
32039 PyObject * obj0 = 0 ;
32040 PyObject * obj1 = 0 ;
32041 PyObject * obj2 = 0 ;
32042 PyObject * obj3 = 0 ;
32043 PyObject * obj4 = 0 ;
32044 char *kwnames[] = {
32045 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32046 };
32047
32048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32050 if (SWIG_arg_fail(1)) SWIG_fail;
32051 {
32052 arg2 = (int)(SWIG_As_int(obj1));
32053 if (SWIG_arg_fail(2)) SWIG_fail;
32054 }
32055 {
32056 arg3 = wxString_in_helper(obj2);
32057 if (arg3 == NULL) SWIG_fail;
32058 temp3 = true;
32059 }
32060 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32061 if (SWIG_arg_fail(4)) SWIG_fail;
32062 if (obj4) {
32063 {
32064 arg5 = wxString_in_helper(obj4);
32065 if (arg5 == NULL) SWIG_fail;
32066 temp5 = true;
32067 }
32068 }
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32072
32073 wxPyEndAllowThreads(__tstate);
32074 if (PyErr_Occurred()) SWIG_fail;
32075 }
32076 {
32077 resultobj = wxPyMake_wxObject(result, 0);
32078 }
32079 {
32080 if (temp3)
32081 delete arg3;
32082 }
32083 {
32084 if (temp5)
32085 delete arg5;
32086 }
32087 return resultobj;
32088 fail:
32089 {
32090 if (temp3)
32091 delete arg3;
32092 }
32093 {
32094 if (temp5)
32095 delete arg5;
32096 }
32097 return NULL;
32098 }
32099
32100
32101 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32102 PyObject *resultobj;
32103 wxMenu *arg1 = (wxMenu *) 0 ;
32104 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32105 wxMenuItem *result;
32106 PyObject * obj0 = 0 ;
32107 PyObject * obj1 = 0 ;
32108 char *kwnames[] = {
32109 (char *) "self",(char *) "item", NULL
32110 };
32111
32112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32114 if (SWIG_arg_fail(1)) SWIG_fail;
32115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32116 if (SWIG_arg_fail(2)) SWIG_fail;
32117 {
32118 PyThreadState* __tstate = wxPyBeginAllowThreads();
32119 result = (wxMenuItem *)(arg1)->Append(arg2);
32120
32121 wxPyEndAllowThreads(__tstate);
32122 if (PyErr_Occurred()) SWIG_fail;
32123 }
32124 {
32125 resultobj = wxPyMake_wxObject(result, 0);
32126 }
32127 return resultobj;
32128 fail:
32129 return NULL;
32130 }
32131
32132
32133 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32134 PyObject *resultobj;
32135 wxMenu *arg1 = (wxMenu *) 0 ;
32136 PyObject * obj0 = 0 ;
32137 char *kwnames[] = {
32138 (char *) "self", NULL
32139 };
32140
32141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32143 if (SWIG_arg_fail(1)) SWIG_fail;
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 (arg1)->Break();
32147
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 Py_INCREF(Py_None); resultobj = Py_None;
32152 return resultobj;
32153 fail:
32154 return NULL;
32155 }
32156
32157
32158 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32159 PyObject *resultobj;
32160 wxMenu *arg1 = (wxMenu *) 0 ;
32161 size_t arg2 ;
32162 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32163 wxMenuItem *result;
32164 PyObject * obj0 = 0 ;
32165 PyObject * obj1 = 0 ;
32166 PyObject * obj2 = 0 ;
32167 char *kwnames[] = {
32168 (char *) "self",(char *) "pos",(char *) "item", NULL
32169 };
32170
32171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32173 if (SWIG_arg_fail(1)) SWIG_fail;
32174 {
32175 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32176 if (SWIG_arg_fail(2)) SWIG_fail;
32177 }
32178 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32179 if (SWIG_arg_fail(3)) SWIG_fail;
32180 {
32181 PyThreadState* __tstate = wxPyBeginAllowThreads();
32182 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32183
32184 wxPyEndAllowThreads(__tstate);
32185 if (PyErr_Occurred()) SWIG_fail;
32186 }
32187 {
32188 resultobj = wxPyMake_wxObject(result, 0);
32189 }
32190 return resultobj;
32191 fail:
32192 return NULL;
32193 }
32194
32195
32196 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32197 PyObject *resultobj;
32198 wxMenu *arg1 = (wxMenu *) 0 ;
32199 size_t arg2 ;
32200 int arg3 ;
32201 wxString *arg4 = 0 ;
32202 wxString const &arg5_defvalue = wxPyEmptyString ;
32203 wxString *arg5 = (wxString *) &arg5_defvalue ;
32204 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32205 wxMenuItem *result;
32206 bool temp4 = false ;
32207 bool temp5 = false ;
32208 PyObject * obj0 = 0 ;
32209 PyObject * obj1 = 0 ;
32210 PyObject * obj2 = 0 ;
32211 PyObject * obj3 = 0 ;
32212 PyObject * obj4 = 0 ;
32213 PyObject * obj5 = 0 ;
32214 char *kwnames[] = {
32215 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32216 };
32217
32218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32220 if (SWIG_arg_fail(1)) SWIG_fail;
32221 {
32222 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32223 if (SWIG_arg_fail(2)) SWIG_fail;
32224 }
32225 {
32226 arg3 = (int)(SWIG_As_int(obj2));
32227 if (SWIG_arg_fail(3)) SWIG_fail;
32228 }
32229 {
32230 arg4 = wxString_in_helper(obj3);
32231 if (arg4 == NULL) SWIG_fail;
32232 temp4 = true;
32233 }
32234 if (obj4) {
32235 {
32236 arg5 = wxString_in_helper(obj4);
32237 if (arg5 == NULL) SWIG_fail;
32238 temp5 = true;
32239 }
32240 }
32241 if (obj5) {
32242 {
32243 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32244 if (SWIG_arg_fail(6)) SWIG_fail;
32245 }
32246 }
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32250
32251 wxPyEndAllowThreads(__tstate);
32252 if (PyErr_Occurred()) SWIG_fail;
32253 }
32254 {
32255 resultobj = wxPyMake_wxObject(result, 0);
32256 }
32257 {
32258 if (temp4)
32259 delete arg4;
32260 }
32261 {
32262 if (temp5)
32263 delete arg5;
32264 }
32265 return resultobj;
32266 fail:
32267 {
32268 if (temp4)
32269 delete arg4;
32270 }
32271 {
32272 if (temp5)
32273 delete arg5;
32274 }
32275 return NULL;
32276 }
32277
32278
32279 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32280 PyObject *resultobj;
32281 wxMenu *arg1 = (wxMenu *) 0 ;
32282 size_t arg2 ;
32283 wxMenuItem *result;
32284 PyObject * obj0 = 0 ;
32285 PyObject * obj1 = 0 ;
32286 char *kwnames[] = {
32287 (char *) "self",(char *) "pos", NULL
32288 };
32289
32290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32292 if (SWIG_arg_fail(1)) SWIG_fail;
32293 {
32294 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32295 if (SWIG_arg_fail(2)) SWIG_fail;
32296 }
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32300
32301 wxPyEndAllowThreads(__tstate);
32302 if (PyErr_Occurred()) SWIG_fail;
32303 }
32304 {
32305 resultobj = wxPyMake_wxObject(result, 0);
32306 }
32307 return resultobj;
32308 fail:
32309 return NULL;
32310 }
32311
32312
32313 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32314 PyObject *resultobj;
32315 wxMenu *arg1 = (wxMenu *) 0 ;
32316 size_t arg2 ;
32317 int arg3 ;
32318 wxString *arg4 = 0 ;
32319 wxString const &arg5_defvalue = wxPyEmptyString ;
32320 wxString *arg5 = (wxString *) &arg5_defvalue ;
32321 wxMenuItem *result;
32322 bool temp4 = false ;
32323 bool temp5 = false ;
32324 PyObject * obj0 = 0 ;
32325 PyObject * obj1 = 0 ;
32326 PyObject * obj2 = 0 ;
32327 PyObject * obj3 = 0 ;
32328 PyObject * obj4 = 0 ;
32329 char *kwnames[] = {
32330 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32331 };
32332
32333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32335 if (SWIG_arg_fail(1)) SWIG_fail;
32336 {
32337 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32338 if (SWIG_arg_fail(2)) SWIG_fail;
32339 }
32340 {
32341 arg3 = (int)(SWIG_As_int(obj2));
32342 if (SWIG_arg_fail(3)) SWIG_fail;
32343 }
32344 {
32345 arg4 = wxString_in_helper(obj3);
32346 if (arg4 == NULL) SWIG_fail;
32347 temp4 = true;
32348 }
32349 if (obj4) {
32350 {
32351 arg5 = wxString_in_helper(obj4);
32352 if (arg5 == NULL) SWIG_fail;
32353 temp5 = true;
32354 }
32355 }
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32359
32360 wxPyEndAllowThreads(__tstate);
32361 if (PyErr_Occurred()) SWIG_fail;
32362 }
32363 {
32364 resultobj = wxPyMake_wxObject(result, 0);
32365 }
32366 {
32367 if (temp4)
32368 delete arg4;
32369 }
32370 {
32371 if (temp5)
32372 delete arg5;
32373 }
32374 return resultobj;
32375 fail:
32376 {
32377 if (temp4)
32378 delete arg4;
32379 }
32380 {
32381 if (temp5)
32382 delete arg5;
32383 }
32384 return NULL;
32385 }
32386
32387
32388 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32389 PyObject *resultobj;
32390 wxMenu *arg1 = (wxMenu *) 0 ;
32391 size_t arg2 ;
32392 int arg3 ;
32393 wxString *arg4 = 0 ;
32394 wxString const &arg5_defvalue = wxPyEmptyString ;
32395 wxString *arg5 = (wxString *) &arg5_defvalue ;
32396 wxMenuItem *result;
32397 bool temp4 = false ;
32398 bool temp5 = false ;
32399 PyObject * obj0 = 0 ;
32400 PyObject * obj1 = 0 ;
32401 PyObject * obj2 = 0 ;
32402 PyObject * obj3 = 0 ;
32403 PyObject * obj4 = 0 ;
32404 char *kwnames[] = {
32405 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32406 };
32407
32408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32410 if (SWIG_arg_fail(1)) SWIG_fail;
32411 {
32412 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32413 if (SWIG_arg_fail(2)) SWIG_fail;
32414 }
32415 {
32416 arg3 = (int)(SWIG_As_int(obj2));
32417 if (SWIG_arg_fail(3)) SWIG_fail;
32418 }
32419 {
32420 arg4 = wxString_in_helper(obj3);
32421 if (arg4 == NULL) SWIG_fail;
32422 temp4 = true;
32423 }
32424 if (obj4) {
32425 {
32426 arg5 = wxString_in_helper(obj4);
32427 if (arg5 == NULL) SWIG_fail;
32428 temp5 = true;
32429 }
32430 }
32431 {
32432 PyThreadState* __tstate = wxPyBeginAllowThreads();
32433 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32434
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 {
32439 resultobj = wxPyMake_wxObject(result, 0);
32440 }
32441 {
32442 if (temp4)
32443 delete arg4;
32444 }
32445 {
32446 if (temp5)
32447 delete arg5;
32448 }
32449 return resultobj;
32450 fail:
32451 {
32452 if (temp4)
32453 delete arg4;
32454 }
32455 {
32456 if (temp5)
32457 delete arg5;
32458 }
32459 return NULL;
32460 }
32461
32462
32463 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32464 PyObject *resultobj;
32465 wxMenu *arg1 = (wxMenu *) 0 ;
32466 size_t arg2 ;
32467 int arg3 ;
32468 wxString *arg4 = 0 ;
32469 wxMenu *arg5 = (wxMenu *) 0 ;
32470 wxString const &arg6_defvalue = wxPyEmptyString ;
32471 wxString *arg6 = (wxString *) &arg6_defvalue ;
32472 wxMenuItem *result;
32473 bool temp4 = false ;
32474 bool temp6 = false ;
32475 PyObject * obj0 = 0 ;
32476 PyObject * obj1 = 0 ;
32477 PyObject * obj2 = 0 ;
32478 PyObject * obj3 = 0 ;
32479 PyObject * obj4 = 0 ;
32480 PyObject * obj5 = 0 ;
32481 char *kwnames[] = {
32482 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32483 };
32484
32485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32487 if (SWIG_arg_fail(1)) SWIG_fail;
32488 {
32489 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32490 if (SWIG_arg_fail(2)) SWIG_fail;
32491 }
32492 {
32493 arg3 = (int)(SWIG_As_int(obj2));
32494 if (SWIG_arg_fail(3)) SWIG_fail;
32495 }
32496 {
32497 arg4 = wxString_in_helper(obj3);
32498 if (arg4 == NULL) SWIG_fail;
32499 temp4 = true;
32500 }
32501 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32502 if (SWIG_arg_fail(5)) SWIG_fail;
32503 if (obj5) {
32504 {
32505 arg6 = wxString_in_helper(obj5);
32506 if (arg6 == NULL) SWIG_fail;
32507 temp6 = true;
32508 }
32509 }
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32513
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 {
32518 resultobj = wxPyMake_wxObject(result, 0);
32519 }
32520 {
32521 if (temp4)
32522 delete arg4;
32523 }
32524 {
32525 if (temp6)
32526 delete arg6;
32527 }
32528 return resultobj;
32529 fail:
32530 {
32531 if (temp4)
32532 delete arg4;
32533 }
32534 {
32535 if (temp6)
32536 delete arg6;
32537 }
32538 return NULL;
32539 }
32540
32541
32542 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32543 PyObject *resultobj;
32544 wxMenu *arg1 = (wxMenu *) 0 ;
32545 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32546 wxMenuItem *result;
32547 PyObject * obj0 = 0 ;
32548 PyObject * obj1 = 0 ;
32549 char *kwnames[] = {
32550 (char *) "self",(char *) "item", NULL
32551 };
32552
32553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32555 if (SWIG_arg_fail(1)) SWIG_fail;
32556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32557 if (SWIG_arg_fail(2)) SWIG_fail;
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32561
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 {
32566 resultobj = wxPyMake_wxObject(result, 0);
32567 }
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32575 PyObject *resultobj;
32576 wxMenu *arg1 = (wxMenu *) 0 ;
32577 int arg2 ;
32578 wxString *arg3 = 0 ;
32579 wxString const &arg4_defvalue = wxPyEmptyString ;
32580 wxString *arg4 = (wxString *) &arg4_defvalue ;
32581 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32582 wxMenuItem *result;
32583 bool temp3 = false ;
32584 bool temp4 = false ;
32585 PyObject * obj0 = 0 ;
32586 PyObject * obj1 = 0 ;
32587 PyObject * obj2 = 0 ;
32588 PyObject * obj3 = 0 ;
32589 PyObject * obj4 = 0 ;
32590 char *kwnames[] = {
32591 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32592 };
32593
32594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32596 if (SWIG_arg_fail(1)) SWIG_fail;
32597 {
32598 arg2 = (int)(SWIG_As_int(obj1));
32599 if (SWIG_arg_fail(2)) SWIG_fail;
32600 }
32601 {
32602 arg3 = wxString_in_helper(obj2);
32603 if (arg3 == NULL) SWIG_fail;
32604 temp3 = true;
32605 }
32606 if (obj3) {
32607 {
32608 arg4 = wxString_in_helper(obj3);
32609 if (arg4 == NULL) SWIG_fail;
32610 temp4 = true;
32611 }
32612 }
32613 if (obj4) {
32614 {
32615 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32616 if (SWIG_arg_fail(5)) SWIG_fail;
32617 }
32618 }
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32622
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 {
32627 resultobj = wxPyMake_wxObject(result, 0);
32628 }
32629 {
32630 if (temp3)
32631 delete arg3;
32632 }
32633 {
32634 if (temp4)
32635 delete arg4;
32636 }
32637 return resultobj;
32638 fail:
32639 {
32640 if (temp3)
32641 delete arg3;
32642 }
32643 {
32644 if (temp4)
32645 delete arg4;
32646 }
32647 return NULL;
32648 }
32649
32650
32651 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32652 PyObject *resultobj;
32653 wxMenu *arg1 = (wxMenu *) 0 ;
32654 wxMenuItem *result;
32655 PyObject * obj0 = 0 ;
32656 char *kwnames[] = {
32657 (char *) "self", NULL
32658 };
32659
32660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32662 if (SWIG_arg_fail(1)) SWIG_fail;
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 result = (wxMenuItem *)(arg1)->PrependSeparator();
32666
32667 wxPyEndAllowThreads(__tstate);
32668 if (PyErr_Occurred()) SWIG_fail;
32669 }
32670 {
32671 resultobj = wxPyMake_wxObject(result, 0);
32672 }
32673 return resultobj;
32674 fail:
32675 return NULL;
32676 }
32677
32678
32679 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32680 PyObject *resultobj;
32681 wxMenu *arg1 = (wxMenu *) 0 ;
32682 int arg2 ;
32683 wxString *arg3 = 0 ;
32684 wxString const &arg4_defvalue = wxPyEmptyString ;
32685 wxString *arg4 = (wxString *) &arg4_defvalue ;
32686 wxMenuItem *result;
32687 bool temp3 = false ;
32688 bool temp4 = false ;
32689 PyObject * obj0 = 0 ;
32690 PyObject * obj1 = 0 ;
32691 PyObject * obj2 = 0 ;
32692 PyObject * obj3 = 0 ;
32693 char *kwnames[] = {
32694 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32695 };
32696
32697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32699 if (SWIG_arg_fail(1)) SWIG_fail;
32700 {
32701 arg2 = (int)(SWIG_As_int(obj1));
32702 if (SWIG_arg_fail(2)) SWIG_fail;
32703 }
32704 {
32705 arg3 = wxString_in_helper(obj2);
32706 if (arg3 == NULL) SWIG_fail;
32707 temp3 = true;
32708 }
32709 if (obj3) {
32710 {
32711 arg4 = wxString_in_helper(obj3);
32712 if (arg4 == NULL) SWIG_fail;
32713 temp4 = true;
32714 }
32715 }
32716 {
32717 PyThreadState* __tstate = wxPyBeginAllowThreads();
32718 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32719
32720 wxPyEndAllowThreads(__tstate);
32721 if (PyErr_Occurred()) SWIG_fail;
32722 }
32723 {
32724 resultobj = wxPyMake_wxObject(result, 0);
32725 }
32726 {
32727 if (temp3)
32728 delete arg3;
32729 }
32730 {
32731 if (temp4)
32732 delete arg4;
32733 }
32734 return resultobj;
32735 fail:
32736 {
32737 if (temp3)
32738 delete arg3;
32739 }
32740 {
32741 if (temp4)
32742 delete arg4;
32743 }
32744 return NULL;
32745 }
32746
32747
32748 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32749 PyObject *resultobj;
32750 wxMenu *arg1 = (wxMenu *) 0 ;
32751 int arg2 ;
32752 wxString *arg3 = 0 ;
32753 wxString const &arg4_defvalue = wxPyEmptyString ;
32754 wxString *arg4 = (wxString *) &arg4_defvalue ;
32755 wxMenuItem *result;
32756 bool temp3 = false ;
32757 bool temp4 = false ;
32758 PyObject * obj0 = 0 ;
32759 PyObject * obj1 = 0 ;
32760 PyObject * obj2 = 0 ;
32761 PyObject * obj3 = 0 ;
32762 char *kwnames[] = {
32763 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32764 };
32765
32766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32768 if (SWIG_arg_fail(1)) SWIG_fail;
32769 {
32770 arg2 = (int)(SWIG_As_int(obj1));
32771 if (SWIG_arg_fail(2)) SWIG_fail;
32772 }
32773 {
32774 arg3 = wxString_in_helper(obj2);
32775 if (arg3 == NULL) SWIG_fail;
32776 temp3 = true;
32777 }
32778 if (obj3) {
32779 {
32780 arg4 = wxString_in_helper(obj3);
32781 if (arg4 == NULL) SWIG_fail;
32782 temp4 = true;
32783 }
32784 }
32785 {
32786 PyThreadState* __tstate = wxPyBeginAllowThreads();
32787 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32788
32789 wxPyEndAllowThreads(__tstate);
32790 if (PyErr_Occurred()) SWIG_fail;
32791 }
32792 {
32793 resultobj = wxPyMake_wxObject(result, 0);
32794 }
32795 {
32796 if (temp3)
32797 delete arg3;
32798 }
32799 {
32800 if (temp4)
32801 delete arg4;
32802 }
32803 return resultobj;
32804 fail:
32805 {
32806 if (temp3)
32807 delete arg3;
32808 }
32809 {
32810 if (temp4)
32811 delete arg4;
32812 }
32813 return NULL;
32814 }
32815
32816
32817 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj;
32819 wxMenu *arg1 = (wxMenu *) 0 ;
32820 int arg2 ;
32821 wxString *arg3 = 0 ;
32822 wxMenu *arg4 = (wxMenu *) 0 ;
32823 wxString const &arg5_defvalue = wxPyEmptyString ;
32824 wxString *arg5 = (wxString *) &arg5_defvalue ;
32825 wxMenuItem *result;
32826 bool temp3 = false ;
32827 bool temp5 = false ;
32828 PyObject * obj0 = 0 ;
32829 PyObject * obj1 = 0 ;
32830 PyObject * obj2 = 0 ;
32831 PyObject * obj3 = 0 ;
32832 PyObject * obj4 = 0 ;
32833 char *kwnames[] = {
32834 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32835 };
32836
32837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32839 if (SWIG_arg_fail(1)) SWIG_fail;
32840 {
32841 arg2 = (int)(SWIG_As_int(obj1));
32842 if (SWIG_arg_fail(2)) SWIG_fail;
32843 }
32844 {
32845 arg3 = wxString_in_helper(obj2);
32846 if (arg3 == NULL) SWIG_fail;
32847 temp3 = true;
32848 }
32849 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32850 if (SWIG_arg_fail(4)) SWIG_fail;
32851 if (obj4) {
32852 {
32853 arg5 = wxString_in_helper(obj4);
32854 if (arg5 == NULL) SWIG_fail;
32855 temp5 = true;
32856 }
32857 }
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32861
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 {
32866 resultobj = wxPyMake_wxObject(result, 0);
32867 }
32868 {
32869 if (temp3)
32870 delete arg3;
32871 }
32872 {
32873 if (temp5)
32874 delete arg5;
32875 }
32876 return resultobj;
32877 fail:
32878 {
32879 if (temp3)
32880 delete arg3;
32881 }
32882 {
32883 if (temp5)
32884 delete arg5;
32885 }
32886 return NULL;
32887 }
32888
32889
32890 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj;
32892 wxMenu *arg1 = (wxMenu *) 0 ;
32893 int arg2 ;
32894 wxMenuItem *result;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 char *kwnames[] = {
32898 (char *) "self",(char *) "id", NULL
32899 };
32900
32901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32903 if (SWIG_arg_fail(1)) SWIG_fail;
32904 {
32905 arg2 = (int)(SWIG_As_int(obj1));
32906 if (SWIG_arg_fail(2)) SWIG_fail;
32907 }
32908 {
32909 PyThreadState* __tstate = wxPyBeginAllowThreads();
32910 result = (wxMenuItem *)(arg1)->Remove(arg2);
32911
32912 wxPyEndAllowThreads(__tstate);
32913 if (PyErr_Occurred()) SWIG_fail;
32914 }
32915 {
32916 resultobj = wxPyMake_wxObject(result, 0);
32917 }
32918 return resultobj;
32919 fail:
32920 return NULL;
32921 }
32922
32923
32924 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32925 PyObject *resultobj;
32926 wxMenu *arg1 = (wxMenu *) 0 ;
32927 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32928 wxMenuItem *result;
32929 PyObject * obj0 = 0 ;
32930 PyObject * obj1 = 0 ;
32931 char *kwnames[] = {
32932 (char *) "self",(char *) "item", NULL
32933 };
32934
32935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32937 if (SWIG_arg_fail(1)) SWIG_fail;
32938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32939 if (SWIG_arg_fail(2)) SWIG_fail;
32940 {
32941 PyThreadState* __tstate = wxPyBeginAllowThreads();
32942 result = (wxMenuItem *)(arg1)->Remove(arg2);
32943
32944 wxPyEndAllowThreads(__tstate);
32945 if (PyErr_Occurred()) SWIG_fail;
32946 }
32947 {
32948 resultobj = wxPyMake_wxObject(result, 0);
32949 }
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
32957 PyObject *resultobj;
32958 wxMenu *arg1 = (wxMenu *) 0 ;
32959 int arg2 ;
32960 bool result;
32961 PyObject * obj0 = 0 ;
32962 PyObject * obj1 = 0 ;
32963 char *kwnames[] = {
32964 (char *) "self",(char *) "id", NULL
32965 };
32966
32967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
32968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32969 if (SWIG_arg_fail(1)) SWIG_fail;
32970 {
32971 arg2 = (int)(SWIG_As_int(obj1));
32972 if (SWIG_arg_fail(2)) SWIG_fail;
32973 }
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 result = (bool)(arg1)->Delete(arg2);
32977
32978 wxPyEndAllowThreads(__tstate);
32979 if (PyErr_Occurred()) SWIG_fail;
32980 }
32981 {
32982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32983 }
32984 return resultobj;
32985 fail:
32986 return NULL;
32987 }
32988
32989
32990 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
32991 PyObject *resultobj;
32992 wxMenu *arg1 = (wxMenu *) 0 ;
32993 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32994 bool result;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 char *kwnames[] = {
32998 (char *) "self",(char *) "item", NULL
32999 };
33000
33001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33003 if (SWIG_arg_fail(1)) SWIG_fail;
33004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33005 if (SWIG_arg_fail(2)) SWIG_fail;
33006 {
33007 PyThreadState* __tstate = wxPyBeginAllowThreads();
33008 result = (bool)(arg1)->Delete(arg2);
33009
33010 wxPyEndAllowThreads(__tstate);
33011 if (PyErr_Occurred()) SWIG_fail;
33012 }
33013 {
33014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33015 }
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33023 PyObject *resultobj;
33024 wxMenu *arg1 = (wxMenu *) 0 ;
33025 PyObject * obj0 = 0 ;
33026 char *kwnames[] = {
33027 (char *) "self", NULL
33028 };
33029
33030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33032 if (SWIG_arg_fail(1)) SWIG_fail;
33033 {
33034 PyThreadState* __tstate = wxPyBeginAllowThreads();
33035 wxMenu_Destroy(arg1);
33036
33037 wxPyEndAllowThreads(__tstate);
33038 if (PyErr_Occurred()) SWIG_fail;
33039 }
33040 Py_INCREF(Py_None); resultobj = Py_None;
33041 return resultobj;
33042 fail:
33043 return NULL;
33044 }
33045
33046
33047 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj;
33049 wxMenu *arg1 = (wxMenu *) 0 ;
33050 int arg2 ;
33051 bool result;
33052 PyObject * obj0 = 0 ;
33053 PyObject * obj1 = 0 ;
33054 char *kwnames[] = {
33055 (char *) "self",(char *) "id", NULL
33056 };
33057
33058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33060 if (SWIG_arg_fail(1)) SWIG_fail;
33061 {
33062 arg2 = (int)(SWIG_As_int(obj1));
33063 if (SWIG_arg_fail(2)) SWIG_fail;
33064 }
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (bool)(arg1)->Destroy(arg2);
33068
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 {
33073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33074 }
33075 return resultobj;
33076 fail:
33077 return NULL;
33078 }
33079
33080
33081 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33082 PyObject *resultobj;
33083 wxMenu *arg1 = (wxMenu *) 0 ;
33084 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33085 bool result;
33086 PyObject * obj0 = 0 ;
33087 PyObject * obj1 = 0 ;
33088 char *kwnames[] = {
33089 (char *) "self",(char *) "item", NULL
33090 };
33091
33092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33094 if (SWIG_arg_fail(1)) SWIG_fail;
33095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33096 if (SWIG_arg_fail(2)) SWIG_fail;
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 result = (bool)(arg1)->Destroy(arg2);
33100
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 {
33105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33106 }
33107 return resultobj;
33108 fail:
33109 return NULL;
33110 }
33111
33112
33113 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33114 PyObject *resultobj;
33115 wxMenu *arg1 = (wxMenu *) 0 ;
33116 size_t result;
33117 PyObject * obj0 = 0 ;
33118 char *kwnames[] = {
33119 (char *) "self", NULL
33120 };
33121
33122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33124 if (SWIG_arg_fail(1)) SWIG_fail;
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33128
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 {
33133 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33134 }
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33142 PyObject *resultobj;
33143 wxMenu *arg1 = (wxMenu *) 0 ;
33144 PyObject *result;
33145 PyObject * obj0 = 0 ;
33146 char *kwnames[] = {
33147 (char *) "self", NULL
33148 };
33149
33150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33152 if (SWIG_arg_fail(1)) SWIG_fail;
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33156
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 resultobj = result;
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj;
33169 wxMenu *arg1 = (wxMenu *) 0 ;
33170 wxString *arg2 = 0 ;
33171 int result;
33172 bool temp2 = false ;
33173 PyObject * obj0 = 0 ;
33174 PyObject * obj1 = 0 ;
33175 char *kwnames[] = {
33176 (char *) "self",(char *) "item", NULL
33177 };
33178
33179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33181 if (SWIG_arg_fail(1)) SWIG_fail;
33182 {
33183 arg2 = wxString_in_helper(obj1);
33184 if (arg2 == NULL) SWIG_fail;
33185 temp2 = true;
33186 }
33187 {
33188 PyThreadState* __tstate = wxPyBeginAllowThreads();
33189 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33190
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 {
33195 resultobj = SWIG_From_int((int)(result));
33196 }
33197 {
33198 if (temp2)
33199 delete arg2;
33200 }
33201 return resultobj;
33202 fail:
33203 {
33204 if (temp2)
33205 delete arg2;
33206 }
33207 return NULL;
33208 }
33209
33210
33211 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33212 PyObject *resultobj;
33213 wxMenu *arg1 = (wxMenu *) 0 ;
33214 int arg2 ;
33215 wxMenuItem *result;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 char *kwnames[] = {
33219 (char *) "self",(char *) "id", NULL
33220 };
33221
33222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33224 if (SWIG_arg_fail(1)) SWIG_fail;
33225 {
33226 arg2 = (int)(SWIG_As_int(obj1));
33227 if (SWIG_arg_fail(2)) SWIG_fail;
33228 }
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33232
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 {
33237 resultobj = wxPyMake_wxObject(result, 0);
33238 }
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33246 PyObject *resultobj;
33247 wxMenu *arg1 = (wxMenu *) 0 ;
33248 size_t arg2 ;
33249 wxMenuItem *result;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 char *kwnames[] = {
33253 (char *) "self",(char *) "position", NULL
33254 };
33255
33256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33258 if (SWIG_arg_fail(1)) SWIG_fail;
33259 {
33260 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33261 if (SWIG_arg_fail(2)) SWIG_fail;
33262 }
33263 {
33264 PyThreadState* __tstate = wxPyBeginAllowThreads();
33265 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33266
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 {
33271 resultobj = wxPyMake_wxObject(result, 0);
33272 }
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj;
33281 wxMenu *arg1 = (wxMenu *) 0 ;
33282 int arg2 ;
33283 bool arg3 ;
33284 PyObject * obj0 = 0 ;
33285 PyObject * obj1 = 0 ;
33286 PyObject * obj2 = 0 ;
33287 char *kwnames[] = {
33288 (char *) "self",(char *) "id",(char *) "enable", NULL
33289 };
33290
33291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33293 if (SWIG_arg_fail(1)) SWIG_fail;
33294 {
33295 arg2 = (int)(SWIG_As_int(obj1));
33296 if (SWIG_arg_fail(2)) SWIG_fail;
33297 }
33298 {
33299 arg3 = (bool)(SWIG_As_bool(obj2));
33300 if (SWIG_arg_fail(3)) SWIG_fail;
33301 }
33302 {
33303 PyThreadState* __tstate = wxPyBeginAllowThreads();
33304 (arg1)->Enable(arg2,arg3);
33305
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 Py_INCREF(Py_None); resultobj = Py_None;
33310 return resultobj;
33311 fail:
33312 return NULL;
33313 }
33314
33315
33316 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33317 PyObject *resultobj;
33318 wxMenu *arg1 = (wxMenu *) 0 ;
33319 int arg2 ;
33320 bool result;
33321 PyObject * obj0 = 0 ;
33322 PyObject * obj1 = 0 ;
33323 char *kwnames[] = {
33324 (char *) "self",(char *) "id", NULL
33325 };
33326
33327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33329 if (SWIG_arg_fail(1)) SWIG_fail;
33330 {
33331 arg2 = (int)(SWIG_As_int(obj1));
33332 if (SWIG_arg_fail(2)) SWIG_fail;
33333 }
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33337
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33351 PyObject *resultobj;
33352 wxMenu *arg1 = (wxMenu *) 0 ;
33353 int arg2 ;
33354 bool arg3 ;
33355 PyObject * obj0 = 0 ;
33356 PyObject * obj1 = 0 ;
33357 PyObject * obj2 = 0 ;
33358 char *kwnames[] = {
33359 (char *) "self",(char *) "id",(char *) "check", NULL
33360 };
33361
33362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33364 if (SWIG_arg_fail(1)) SWIG_fail;
33365 {
33366 arg2 = (int)(SWIG_As_int(obj1));
33367 if (SWIG_arg_fail(2)) SWIG_fail;
33368 }
33369 {
33370 arg3 = (bool)(SWIG_As_bool(obj2));
33371 if (SWIG_arg_fail(3)) SWIG_fail;
33372 }
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 (arg1)->Check(arg2,arg3);
33376
33377 wxPyEndAllowThreads(__tstate);
33378 if (PyErr_Occurred()) SWIG_fail;
33379 }
33380 Py_INCREF(Py_None); resultobj = Py_None;
33381 return resultobj;
33382 fail:
33383 return NULL;
33384 }
33385
33386
33387 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33388 PyObject *resultobj;
33389 wxMenu *arg1 = (wxMenu *) 0 ;
33390 int arg2 ;
33391 bool result;
33392 PyObject * obj0 = 0 ;
33393 PyObject * obj1 = 0 ;
33394 char *kwnames[] = {
33395 (char *) "self",(char *) "id", NULL
33396 };
33397
33398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33400 if (SWIG_arg_fail(1)) SWIG_fail;
33401 {
33402 arg2 = (int)(SWIG_As_int(obj1));
33403 if (SWIG_arg_fail(2)) SWIG_fail;
33404 }
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33408
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 {
33413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33414 }
33415 return resultobj;
33416 fail:
33417 return NULL;
33418 }
33419
33420
33421 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33422 PyObject *resultobj;
33423 wxMenu *arg1 = (wxMenu *) 0 ;
33424 int arg2 ;
33425 wxString *arg3 = 0 ;
33426 bool temp3 = false ;
33427 PyObject * obj0 = 0 ;
33428 PyObject * obj1 = 0 ;
33429 PyObject * obj2 = 0 ;
33430 char *kwnames[] = {
33431 (char *) "self",(char *) "id",(char *) "label", NULL
33432 };
33433
33434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33436 if (SWIG_arg_fail(1)) SWIG_fail;
33437 {
33438 arg2 = (int)(SWIG_As_int(obj1));
33439 if (SWIG_arg_fail(2)) SWIG_fail;
33440 }
33441 {
33442 arg3 = wxString_in_helper(obj2);
33443 if (arg3 == NULL) SWIG_fail;
33444 temp3 = true;
33445 }
33446 {
33447 PyThreadState* __tstate = wxPyBeginAllowThreads();
33448 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33449
33450 wxPyEndAllowThreads(__tstate);
33451 if (PyErr_Occurred()) SWIG_fail;
33452 }
33453 Py_INCREF(Py_None); resultobj = Py_None;
33454 {
33455 if (temp3)
33456 delete arg3;
33457 }
33458 return resultobj;
33459 fail:
33460 {
33461 if (temp3)
33462 delete arg3;
33463 }
33464 return NULL;
33465 }
33466
33467
33468 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj;
33470 wxMenu *arg1 = (wxMenu *) 0 ;
33471 int arg2 ;
33472 wxString result;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char *kwnames[] = {
33476 (char *) "self",(char *) "id", NULL
33477 };
33478
33479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33481 if (SWIG_arg_fail(1)) SWIG_fail;
33482 {
33483 arg2 = (int)(SWIG_As_int(obj1));
33484 if (SWIG_arg_fail(2)) SWIG_fail;
33485 }
33486 {
33487 PyThreadState* __tstate = wxPyBeginAllowThreads();
33488 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33489
33490 wxPyEndAllowThreads(__tstate);
33491 if (PyErr_Occurred()) SWIG_fail;
33492 }
33493 {
33494 #if wxUSE_UNICODE
33495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33496 #else
33497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33498 #endif
33499 }
33500 return resultobj;
33501 fail:
33502 return NULL;
33503 }
33504
33505
33506 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33507 PyObject *resultobj;
33508 wxMenu *arg1 = (wxMenu *) 0 ;
33509 int arg2 ;
33510 wxString *arg3 = 0 ;
33511 bool temp3 = false ;
33512 PyObject * obj0 = 0 ;
33513 PyObject * obj1 = 0 ;
33514 PyObject * obj2 = 0 ;
33515 char *kwnames[] = {
33516 (char *) "self",(char *) "id",(char *) "helpString", NULL
33517 };
33518
33519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33521 if (SWIG_arg_fail(1)) SWIG_fail;
33522 {
33523 arg2 = (int)(SWIG_As_int(obj1));
33524 if (SWIG_arg_fail(2)) SWIG_fail;
33525 }
33526 {
33527 arg3 = wxString_in_helper(obj2);
33528 if (arg3 == NULL) SWIG_fail;
33529 temp3 = true;
33530 }
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33534
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 Py_INCREF(Py_None); resultobj = Py_None;
33539 {
33540 if (temp3)
33541 delete arg3;
33542 }
33543 return resultobj;
33544 fail:
33545 {
33546 if (temp3)
33547 delete arg3;
33548 }
33549 return NULL;
33550 }
33551
33552
33553 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33554 PyObject *resultobj;
33555 wxMenu *arg1 = (wxMenu *) 0 ;
33556 int arg2 ;
33557 wxString result;
33558 PyObject * obj0 = 0 ;
33559 PyObject * obj1 = 0 ;
33560 char *kwnames[] = {
33561 (char *) "self",(char *) "id", NULL
33562 };
33563
33564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33566 if (SWIG_arg_fail(1)) SWIG_fail;
33567 {
33568 arg2 = (int)(SWIG_As_int(obj1));
33569 if (SWIG_arg_fail(2)) SWIG_fail;
33570 }
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33574
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 {
33579 #if wxUSE_UNICODE
33580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33581 #else
33582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33583 #endif
33584 }
33585 return resultobj;
33586 fail:
33587 return NULL;
33588 }
33589
33590
33591 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33592 PyObject *resultobj;
33593 wxMenu *arg1 = (wxMenu *) 0 ;
33594 wxString *arg2 = 0 ;
33595 bool temp2 = false ;
33596 PyObject * obj0 = 0 ;
33597 PyObject * obj1 = 0 ;
33598 char *kwnames[] = {
33599 (char *) "self",(char *) "title", NULL
33600 };
33601
33602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33604 if (SWIG_arg_fail(1)) SWIG_fail;
33605 {
33606 arg2 = wxString_in_helper(obj1);
33607 if (arg2 == NULL) SWIG_fail;
33608 temp2 = true;
33609 }
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 (arg1)->SetTitle((wxString const &)*arg2);
33613
33614 wxPyEndAllowThreads(__tstate);
33615 if (PyErr_Occurred()) SWIG_fail;
33616 }
33617 Py_INCREF(Py_None); resultobj = Py_None;
33618 {
33619 if (temp2)
33620 delete arg2;
33621 }
33622 return resultobj;
33623 fail:
33624 {
33625 if (temp2)
33626 delete arg2;
33627 }
33628 return NULL;
33629 }
33630
33631
33632 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33633 PyObject *resultobj;
33634 wxMenu *arg1 = (wxMenu *) 0 ;
33635 wxString result;
33636 PyObject * obj0 = 0 ;
33637 char *kwnames[] = {
33638 (char *) "self", NULL
33639 };
33640
33641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33643 if (SWIG_arg_fail(1)) SWIG_fail;
33644 {
33645 PyThreadState* __tstate = wxPyBeginAllowThreads();
33646 result = ((wxMenu const *)arg1)->GetTitle();
33647
33648 wxPyEndAllowThreads(__tstate);
33649 if (PyErr_Occurred()) SWIG_fail;
33650 }
33651 {
33652 #if wxUSE_UNICODE
33653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33654 #else
33655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33656 #endif
33657 }
33658 return resultobj;
33659 fail:
33660 return NULL;
33661 }
33662
33663
33664 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33665 PyObject *resultobj;
33666 wxMenu *arg1 = (wxMenu *) 0 ;
33667 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33668 PyObject * obj0 = 0 ;
33669 PyObject * obj1 = 0 ;
33670 char *kwnames[] = {
33671 (char *) "self",(char *) "handler", NULL
33672 };
33673
33674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33676 if (SWIG_arg_fail(1)) SWIG_fail;
33677 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33678 if (SWIG_arg_fail(2)) SWIG_fail;
33679 {
33680 PyThreadState* __tstate = wxPyBeginAllowThreads();
33681 (arg1)->SetEventHandler(arg2);
33682
33683 wxPyEndAllowThreads(__tstate);
33684 if (PyErr_Occurred()) SWIG_fail;
33685 }
33686 Py_INCREF(Py_None); resultobj = Py_None;
33687 return resultobj;
33688 fail:
33689 return NULL;
33690 }
33691
33692
33693 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33694 PyObject *resultobj;
33695 wxMenu *arg1 = (wxMenu *) 0 ;
33696 wxEvtHandler *result;
33697 PyObject * obj0 = 0 ;
33698 char *kwnames[] = {
33699 (char *) "self", NULL
33700 };
33701
33702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33704 if (SWIG_arg_fail(1)) SWIG_fail;
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33708
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 {
33713 resultobj = wxPyMake_wxObject(result, 0);
33714 }
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33722 PyObject *resultobj;
33723 wxMenu *arg1 = (wxMenu *) 0 ;
33724 wxWindow *arg2 = (wxWindow *) 0 ;
33725 PyObject * obj0 = 0 ;
33726 PyObject * obj1 = 0 ;
33727 char *kwnames[] = {
33728 (char *) "self",(char *) "win", NULL
33729 };
33730
33731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33733 if (SWIG_arg_fail(1)) SWIG_fail;
33734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33735 if (SWIG_arg_fail(2)) SWIG_fail;
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 (arg1)->SetInvokingWindow(arg2);
33739
33740 wxPyEndAllowThreads(__tstate);
33741 if (PyErr_Occurred()) SWIG_fail;
33742 }
33743 Py_INCREF(Py_None); resultobj = Py_None;
33744 return resultobj;
33745 fail:
33746 return NULL;
33747 }
33748
33749
33750 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33751 PyObject *resultobj;
33752 wxMenu *arg1 = (wxMenu *) 0 ;
33753 wxWindow *result;
33754 PyObject * obj0 = 0 ;
33755 char *kwnames[] = {
33756 (char *) "self", NULL
33757 };
33758
33759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33761 if (SWIG_arg_fail(1)) SWIG_fail;
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33765
33766 wxPyEndAllowThreads(__tstate);
33767 if (PyErr_Occurred()) SWIG_fail;
33768 }
33769 {
33770 resultobj = wxPyMake_wxObject(result, 0);
33771 }
33772 return resultobj;
33773 fail:
33774 return NULL;
33775 }
33776
33777
33778 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33779 PyObject *resultobj;
33780 wxMenu *arg1 = (wxMenu *) 0 ;
33781 long result;
33782 PyObject * obj0 = 0 ;
33783 char *kwnames[] = {
33784 (char *) "self", NULL
33785 };
33786
33787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33789 if (SWIG_arg_fail(1)) SWIG_fail;
33790 {
33791 PyThreadState* __tstate = wxPyBeginAllowThreads();
33792 result = (long)((wxMenu const *)arg1)->GetStyle();
33793
33794 wxPyEndAllowThreads(__tstate);
33795 if (PyErr_Occurred()) SWIG_fail;
33796 }
33797 {
33798 resultobj = SWIG_From_long((long)(result));
33799 }
33800 return resultobj;
33801 fail:
33802 return NULL;
33803 }
33804
33805
33806 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj;
33808 wxMenu *arg1 = (wxMenu *) 0 ;
33809 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 char *kwnames[] = {
33813 (char *) "self",(char *) "source", NULL
33814 };
33815
33816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33818 if (SWIG_arg_fail(1)) SWIG_fail;
33819 if (obj1) {
33820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33821 if (SWIG_arg_fail(2)) SWIG_fail;
33822 }
33823 {
33824 PyThreadState* __tstate = wxPyBeginAllowThreads();
33825 (arg1)->UpdateUI(arg2);
33826
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 Py_INCREF(Py_None); resultobj = Py_None;
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33838 PyObject *resultobj;
33839 wxMenu *arg1 = (wxMenu *) 0 ;
33840 wxMenuBar *result;
33841 PyObject * obj0 = 0 ;
33842 char *kwnames[] = {
33843 (char *) "self", NULL
33844 };
33845
33846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33848 if (SWIG_arg_fail(1)) SWIG_fail;
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33852
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 {
33857 resultobj = wxPyMake_wxObject(result, 0);
33858 }
33859 return resultobj;
33860 fail:
33861 return NULL;
33862 }
33863
33864
33865 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33866 PyObject *resultobj;
33867 wxMenu *arg1 = (wxMenu *) 0 ;
33868 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char *kwnames[] = {
33872 (char *) "self",(char *) "menubar", NULL
33873 };
33874
33875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33877 if (SWIG_arg_fail(1)) SWIG_fail;
33878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33879 if (SWIG_arg_fail(2)) SWIG_fail;
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 (arg1)->Attach(arg2);
33883
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 Py_INCREF(Py_None); resultobj = Py_None;
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33895 PyObject *resultobj;
33896 wxMenu *arg1 = (wxMenu *) 0 ;
33897 PyObject * obj0 = 0 ;
33898 char *kwnames[] = {
33899 (char *) "self", NULL
33900 };
33901
33902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33904 if (SWIG_arg_fail(1)) SWIG_fail;
33905 {
33906 PyThreadState* __tstate = wxPyBeginAllowThreads();
33907 (arg1)->Detach();
33908
33909 wxPyEndAllowThreads(__tstate);
33910 if (PyErr_Occurred()) SWIG_fail;
33911 }
33912 Py_INCREF(Py_None); resultobj = Py_None;
33913 return resultobj;
33914 fail:
33915 return NULL;
33916 }
33917
33918
33919 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33920 PyObject *resultobj;
33921 wxMenu *arg1 = (wxMenu *) 0 ;
33922 bool result;
33923 PyObject * obj0 = 0 ;
33924 char *kwnames[] = {
33925 (char *) "self", NULL
33926 };
33927
33928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33930 if (SWIG_arg_fail(1)) SWIG_fail;
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 result = (bool)((wxMenu const *)arg1)->IsAttached();
33934
33935 wxPyEndAllowThreads(__tstate);
33936 if (PyErr_Occurred()) SWIG_fail;
33937 }
33938 {
33939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33940 }
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj;
33949 wxMenu *arg1 = (wxMenu *) 0 ;
33950 wxMenu *arg2 = (wxMenu *) 0 ;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char *kwnames[] = {
33954 (char *) "self",(char *) "parent", NULL
33955 };
33956
33957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",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_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33961 if (SWIG_arg_fail(2)) SWIG_fail;
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 (arg1)->SetParent(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_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33977 PyObject *resultobj;
33978 wxMenu *arg1 = (wxMenu *) 0 ;
33979 wxMenu *result;
33980 PyObject * obj0 = 0 ;
33981 char *kwnames[] = {
33982 (char *) "self", NULL
33983 };
33984
33985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",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 = (wxMenu *)((wxMenu const *)arg1)->GetParent();
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 * Menu_swigregister(PyObject *, PyObject *args) {
34005 PyObject *obj;
34006 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34007 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34008 Py_INCREF(obj);
34009 return Py_BuildValue((char *)"");
34010 }
34011 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj;
34013 long arg1 = (long) 0 ;
34014 wxMenuBar *result;
34015 PyObject * obj0 = 0 ;
34016 char *kwnames[] = {
34017 (char *) "style", NULL
34018 };
34019
34020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34021 if (obj0) {
34022 {
34023 arg1 = (long)(SWIG_As_long(obj0));
34024 if (SWIG_arg_fail(1)) SWIG_fail;
34025 }
34026 }
34027 {
34028 if (!wxPyCheckForApp()) SWIG_fail;
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 result = (wxMenuBar *)new wxMenuBar(arg1);
34031
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34043 PyObject *resultobj;
34044 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34045 wxMenu *arg2 = (wxMenu *) 0 ;
34046 wxString *arg3 = 0 ;
34047 bool result;
34048 bool temp3 = false ;
34049 PyObject * obj0 = 0 ;
34050 PyObject * obj1 = 0 ;
34051 PyObject * obj2 = 0 ;
34052 char *kwnames[] = {
34053 (char *) "self",(char *) "menu",(char *) "title", NULL
34054 };
34055
34056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34058 if (SWIG_arg_fail(1)) SWIG_fail;
34059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34060 if (SWIG_arg_fail(2)) SWIG_fail;
34061 {
34062 arg3 = wxString_in_helper(obj2);
34063 if (arg3 == NULL) SWIG_fail;
34064 temp3 = true;
34065 }
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34069
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 {
34074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34075 }
34076 {
34077 if (temp3)
34078 delete arg3;
34079 }
34080 return resultobj;
34081 fail:
34082 {
34083 if (temp3)
34084 delete arg3;
34085 }
34086 return NULL;
34087 }
34088
34089
34090 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34091 PyObject *resultobj;
34092 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34093 size_t arg2 ;
34094 wxMenu *arg3 = (wxMenu *) 0 ;
34095 wxString *arg4 = 0 ;
34096 bool result;
34097 bool temp4 = false ;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 PyObject * obj2 = 0 ;
34101 PyObject * obj3 = 0 ;
34102 char *kwnames[] = {
34103 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34104 };
34105
34106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34108 if (SWIG_arg_fail(1)) SWIG_fail;
34109 {
34110 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34111 if (SWIG_arg_fail(2)) SWIG_fail;
34112 }
34113 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34114 if (SWIG_arg_fail(3)) SWIG_fail;
34115 {
34116 arg4 = wxString_in_helper(obj3);
34117 if (arg4 == NULL) SWIG_fail;
34118 temp4 = true;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 {
34128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34129 }
34130 {
34131 if (temp4)
34132 delete arg4;
34133 }
34134 return resultobj;
34135 fail:
34136 {
34137 if (temp4)
34138 delete arg4;
34139 }
34140 return NULL;
34141 }
34142
34143
34144 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj;
34146 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34147 size_t result;
34148 PyObject * obj0 = 0 ;
34149 char *kwnames[] = {
34150 (char *) "self", NULL
34151 };
34152
34153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34155 if (SWIG_arg_fail(1)) SWIG_fail;
34156 {
34157 PyThreadState* __tstate = wxPyBeginAllowThreads();
34158 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34159
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 {
34164 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34165 }
34166 return resultobj;
34167 fail:
34168 return NULL;
34169 }
34170
34171
34172 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34173 PyObject *resultobj;
34174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34175 size_t arg2 ;
34176 wxMenu *result;
34177 PyObject * obj0 = 0 ;
34178 PyObject * obj1 = 0 ;
34179 char *kwnames[] = {
34180 (char *) "self",(char *) "pos", NULL
34181 };
34182
34183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34185 if (SWIG_arg_fail(1)) SWIG_fail;
34186 {
34187 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34188 if (SWIG_arg_fail(2)) SWIG_fail;
34189 }
34190 {
34191 PyThreadState* __tstate = wxPyBeginAllowThreads();
34192 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34193
34194 wxPyEndAllowThreads(__tstate);
34195 if (PyErr_Occurred()) SWIG_fail;
34196 }
34197 {
34198 resultobj = wxPyMake_wxObject(result, 0);
34199 }
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34207 PyObject *resultobj;
34208 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34209 size_t arg2 ;
34210 wxMenu *arg3 = (wxMenu *) 0 ;
34211 wxString *arg4 = 0 ;
34212 wxMenu *result;
34213 bool temp4 = false ;
34214 PyObject * obj0 = 0 ;
34215 PyObject * obj1 = 0 ;
34216 PyObject * obj2 = 0 ;
34217 PyObject * obj3 = 0 ;
34218 char *kwnames[] = {
34219 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34220 };
34221
34222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34224 if (SWIG_arg_fail(1)) SWIG_fail;
34225 {
34226 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34227 if (SWIG_arg_fail(2)) SWIG_fail;
34228 }
34229 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34230 if (SWIG_arg_fail(3)) SWIG_fail;
34231 {
34232 arg4 = wxString_in_helper(obj3);
34233 if (arg4 == NULL) SWIG_fail;
34234 temp4 = true;
34235 }
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34239
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 {
34244 resultobj = wxPyMake_wxObject(result, 0);
34245 }
34246 {
34247 if (temp4)
34248 delete arg4;
34249 }
34250 return resultobj;
34251 fail:
34252 {
34253 if (temp4)
34254 delete arg4;
34255 }
34256 return NULL;
34257 }
34258
34259
34260 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34261 PyObject *resultobj;
34262 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34263 size_t arg2 ;
34264 wxMenu *result;
34265 PyObject * obj0 = 0 ;
34266 PyObject * obj1 = 0 ;
34267 char *kwnames[] = {
34268 (char *) "self",(char *) "pos", NULL
34269 };
34270
34271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34273 if (SWIG_arg_fail(1)) SWIG_fail;
34274 {
34275 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34276 if (SWIG_arg_fail(2)) SWIG_fail;
34277 }
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 result = (wxMenu *)(arg1)->Remove(arg2);
34281
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 {
34286 resultobj = wxPyMake_wxObject(result, 0);
34287 }
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34297 size_t arg2 ;
34298 bool arg3 ;
34299 PyObject * obj0 = 0 ;
34300 PyObject * obj1 = 0 ;
34301 PyObject * obj2 = 0 ;
34302 char *kwnames[] = {
34303 (char *) "self",(char *) "pos",(char *) "enable", NULL
34304 };
34305
34306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34308 if (SWIG_arg_fail(1)) SWIG_fail;
34309 {
34310 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34311 if (SWIG_arg_fail(2)) SWIG_fail;
34312 }
34313 {
34314 arg3 = (bool)(SWIG_As_bool(obj2));
34315 if (SWIG_arg_fail(3)) SWIG_fail;
34316 }
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 (arg1)->EnableTop(arg2,arg3);
34320
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 Py_INCREF(Py_None); resultobj = Py_None;
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj;
34333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34334 size_t arg2 ;
34335 bool result;
34336 PyObject * obj0 = 0 ;
34337 PyObject * obj1 = 0 ;
34338 char *kwnames[] = {
34339 (char *) "self",(char *) "pos", NULL
34340 };
34341
34342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34344 if (SWIG_arg_fail(1)) SWIG_fail;
34345 {
34346 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34347 if (SWIG_arg_fail(2)) SWIG_fail;
34348 }
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34352
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 {
34357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34358 }
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34366 PyObject *resultobj;
34367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34368 size_t arg2 ;
34369 wxString *arg3 = 0 ;
34370 bool temp3 = false ;
34371 PyObject * obj0 = 0 ;
34372 PyObject * obj1 = 0 ;
34373 PyObject * obj2 = 0 ;
34374 char *kwnames[] = {
34375 (char *) "self",(char *) "pos",(char *) "label", NULL
34376 };
34377
34378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(1)) SWIG_fail;
34381 {
34382 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34383 if (SWIG_arg_fail(2)) SWIG_fail;
34384 }
34385 {
34386 arg3 = wxString_in_helper(obj2);
34387 if (arg3 == NULL) SWIG_fail;
34388 temp3 = true;
34389 }
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34393
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 Py_INCREF(Py_None); resultobj = Py_None;
34398 {
34399 if (temp3)
34400 delete arg3;
34401 }
34402 return resultobj;
34403 fail:
34404 {
34405 if (temp3)
34406 delete arg3;
34407 }
34408 return NULL;
34409 }
34410
34411
34412 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34413 PyObject *resultobj;
34414 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34415 size_t arg2 ;
34416 wxString result;
34417 PyObject * obj0 = 0 ;
34418 PyObject * obj1 = 0 ;
34419 char *kwnames[] = {
34420 (char *) "self",(char *) "pos", NULL
34421 };
34422
34423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34425 if (SWIG_arg_fail(1)) SWIG_fail;
34426 {
34427 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34428 if (SWIG_arg_fail(2)) SWIG_fail;
34429 }
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34433
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 #if wxUSE_UNICODE
34439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34440 #else
34441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34442 #endif
34443 }
34444 return resultobj;
34445 fail:
34446 return NULL;
34447 }
34448
34449
34450 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34451 PyObject *resultobj;
34452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34453 wxString *arg2 = 0 ;
34454 wxString *arg3 = 0 ;
34455 int result;
34456 bool temp2 = false ;
34457 bool temp3 = false ;
34458 PyObject * obj0 = 0 ;
34459 PyObject * obj1 = 0 ;
34460 PyObject * obj2 = 0 ;
34461 char *kwnames[] = {
34462 (char *) "self",(char *) "menu",(char *) "item", NULL
34463 };
34464
34465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34467 if (SWIG_arg_fail(1)) SWIG_fail;
34468 {
34469 arg2 = wxString_in_helper(obj1);
34470 if (arg2 == NULL) SWIG_fail;
34471 temp2 = true;
34472 }
34473 {
34474 arg3 = wxString_in_helper(obj2);
34475 if (arg3 == NULL) SWIG_fail;
34476 temp3 = true;
34477 }
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34481
34482 wxPyEndAllowThreads(__tstate);
34483 if (PyErr_Occurred()) SWIG_fail;
34484 }
34485 {
34486 resultobj = SWIG_From_int((int)(result));
34487 }
34488 {
34489 if (temp2)
34490 delete arg2;
34491 }
34492 {
34493 if (temp3)
34494 delete arg3;
34495 }
34496 return resultobj;
34497 fail:
34498 {
34499 if (temp2)
34500 delete arg2;
34501 }
34502 {
34503 if (temp3)
34504 delete arg3;
34505 }
34506 return NULL;
34507 }
34508
34509
34510 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34511 PyObject *resultobj;
34512 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34513 int arg2 ;
34514 wxMenuItem *result;
34515 PyObject * obj0 = 0 ;
34516 PyObject * obj1 = 0 ;
34517 char *kwnames[] = {
34518 (char *) "self",(char *) "id", NULL
34519 };
34520
34521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34523 if (SWIG_arg_fail(1)) SWIG_fail;
34524 {
34525 arg2 = (int)(SWIG_As_int(obj1));
34526 if (SWIG_arg_fail(2)) SWIG_fail;
34527 }
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34531
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 {
34536 resultobj = wxPyMake_wxObject(result, 0);
34537 }
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34545 PyObject *resultobj;
34546 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34547 wxString *arg2 = 0 ;
34548 int result;
34549 bool temp2 = false ;
34550 PyObject * obj0 = 0 ;
34551 PyObject * obj1 = 0 ;
34552 char *kwnames[] = {
34553 (char *) "self",(char *) "title", NULL
34554 };
34555
34556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34558 if (SWIG_arg_fail(1)) SWIG_fail;
34559 {
34560 arg2 = wxString_in_helper(obj1);
34561 if (arg2 == NULL) SWIG_fail;
34562 temp2 = true;
34563 }
34564 {
34565 PyThreadState* __tstate = wxPyBeginAllowThreads();
34566 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34567
34568 wxPyEndAllowThreads(__tstate);
34569 if (PyErr_Occurred()) SWIG_fail;
34570 }
34571 {
34572 resultobj = SWIG_From_int((int)(result));
34573 }
34574 {
34575 if (temp2)
34576 delete arg2;
34577 }
34578 return resultobj;
34579 fail:
34580 {
34581 if (temp2)
34582 delete arg2;
34583 }
34584 return NULL;
34585 }
34586
34587
34588 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34589 PyObject *resultobj;
34590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34591 int arg2 ;
34592 bool arg3 ;
34593 PyObject * obj0 = 0 ;
34594 PyObject * obj1 = 0 ;
34595 PyObject * obj2 = 0 ;
34596 char *kwnames[] = {
34597 (char *) "self",(char *) "id",(char *) "enable", NULL
34598 };
34599
34600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34602 if (SWIG_arg_fail(1)) SWIG_fail;
34603 {
34604 arg2 = (int)(SWIG_As_int(obj1));
34605 if (SWIG_arg_fail(2)) SWIG_fail;
34606 }
34607 {
34608 arg3 = (bool)(SWIG_As_bool(obj2));
34609 if (SWIG_arg_fail(3)) SWIG_fail;
34610 }
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 (arg1)->Enable(arg2,arg3);
34614
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 Py_INCREF(Py_None); resultobj = Py_None;
34619 return resultobj;
34620 fail:
34621 return NULL;
34622 }
34623
34624
34625 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34626 PyObject *resultobj;
34627 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34628 int arg2 ;
34629 bool arg3 ;
34630 PyObject * obj0 = 0 ;
34631 PyObject * obj1 = 0 ;
34632 PyObject * obj2 = 0 ;
34633 char *kwnames[] = {
34634 (char *) "self",(char *) "id",(char *) "check", NULL
34635 };
34636
34637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34639 if (SWIG_arg_fail(1)) SWIG_fail;
34640 {
34641 arg2 = (int)(SWIG_As_int(obj1));
34642 if (SWIG_arg_fail(2)) SWIG_fail;
34643 }
34644 {
34645 arg3 = (bool)(SWIG_As_bool(obj2));
34646 if (SWIG_arg_fail(3)) SWIG_fail;
34647 }
34648 {
34649 PyThreadState* __tstate = wxPyBeginAllowThreads();
34650 (arg1)->Check(arg2,arg3);
34651
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 Py_INCREF(Py_None); resultobj = Py_None;
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj;
34664 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34665 int arg2 ;
34666 bool result;
34667 PyObject * obj0 = 0 ;
34668 PyObject * obj1 = 0 ;
34669 char *kwnames[] = {
34670 (char *) "self",(char *) "id", NULL
34671 };
34672
34673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34675 if (SWIG_arg_fail(1)) SWIG_fail;
34676 {
34677 arg2 = (int)(SWIG_As_int(obj1));
34678 if (SWIG_arg_fail(2)) SWIG_fail;
34679 }
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34683
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 {
34688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34689 }
34690 return resultobj;
34691 fail:
34692 return NULL;
34693 }
34694
34695
34696 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34697 PyObject *resultobj;
34698 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34699 int arg2 ;
34700 bool result;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char *kwnames[] = {
34704 (char *) "self",(char *) "id", NULL
34705 };
34706
34707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34709 if (SWIG_arg_fail(1)) SWIG_fail;
34710 {
34711 arg2 = (int)(SWIG_As_int(obj1));
34712 if (SWIG_arg_fail(2)) SWIG_fail;
34713 }
34714 {
34715 PyThreadState* __tstate = wxPyBeginAllowThreads();
34716 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34717
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 {
34722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34723 }
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj;
34732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34733 int arg2 ;
34734 wxString *arg3 = 0 ;
34735 bool temp3 = false ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 PyObject * obj2 = 0 ;
34739 char *kwnames[] = {
34740 (char *) "self",(char *) "id",(char *) "label", NULL
34741 };
34742
34743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34745 if (SWIG_arg_fail(1)) SWIG_fail;
34746 {
34747 arg2 = (int)(SWIG_As_int(obj1));
34748 if (SWIG_arg_fail(2)) SWIG_fail;
34749 }
34750 {
34751 arg3 = wxString_in_helper(obj2);
34752 if (arg3 == NULL) SWIG_fail;
34753 temp3 = true;
34754 }
34755 {
34756 PyThreadState* __tstate = wxPyBeginAllowThreads();
34757 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34758
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 Py_INCREF(Py_None); resultobj = Py_None;
34763 {
34764 if (temp3)
34765 delete arg3;
34766 }
34767 return resultobj;
34768 fail:
34769 {
34770 if (temp3)
34771 delete arg3;
34772 }
34773 return NULL;
34774 }
34775
34776
34777 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj;
34779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34780 int arg2 ;
34781 wxString result;
34782 PyObject * obj0 = 0 ;
34783 PyObject * obj1 = 0 ;
34784 char *kwnames[] = {
34785 (char *) "self",(char *) "id", NULL
34786 };
34787
34788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(1)) SWIG_fail;
34791 {
34792 arg2 = (int)(SWIG_As_int(obj1));
34793 if (SWIG_arg_fail(2)) SWIG_fail;
34794 }
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34798
34799 wxPyEndAllowThreads(__tstate);
34800 if (PyErr_Occurred()) SWIG_fail;
34801 }
34802 {
34803 #if wxUSE_UNICODE
34804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34805 #else
34806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34807 #endif
34808 }
34809 return resultobj;
34810 fail:
34811 return NULL;
34812 }
34813
34814
34815 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34816 PyObject *resultobj;
34817 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34818 int arg2 ;
34819 wxString *arg3 = 0 ;
34820 bool temp3 = false ;
34821 PyObject * obj0 = 0 ;
34822 PyObject * obj1 = 0 ;
34823 PyObject * obj2 = 0 ;
34824 char *kwnames[] = {
34825 (char *) "self",(char *) "id",(char *) "helpString", NULL
34826 };
34827
34828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34830 if (SWIG_arg_fail(1)) SWIG_fail;
34831 {
34832 arg2 = (int)(SWIG_As_int(obj1));
34833 if (SWIG_arg_fail(2)) SWIG_fail;
34834 }
34835 {
34836 arg3 = wxString_in_helper(obj2);
34837 if (arg3 == NULL) SWIG_fail;
34838 temp3 = true;
34839 }
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34843
34844 wxPyEndAllowThreads(__tstate);
34845 if (PyErr_Occurred()) SWIG_fail;
34846 }
34847 Py_INCREF(Py_None); resultobj = Py_None;
34848 {
34849 if (temp3)
34850 delete arg3;
34851 }
34852 return resultobj;
34853 fail:
34854 {
34855 if (temp3)
34856 delete arg3;
34857 }
34858 return NULL;
34859 }
34860
34861
34862 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34863 PyObject *resultobj;
34864 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34865 int arg2 ;
34866 wxString result;
34867 PyObject * obj0 = 0 ;
34868 PyObject * obj1 = 0 ;
34869 char *kwnames[] = {
34870 (char *) "self",(char *) "id", NULL
34871 };
34872
34873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34875 if (SWIG_arg_fail(1)) SWIG_fail;
34876 {
34877 arg2 = (int)(SWIG_As_int(obj1));
34878 if (SWIG_arg_fail(2)) SWIG_fail;
34879 }
34880 {
34881 PyThreadState* __tstate = wxPyBeginAllowThreads();
34882 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34883
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 {
34888 #if wxUSE_UNICODE
34889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34890 #else
34891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34892 #endif
34893 }
34894 return resultobj;
34895 fail:
34896 return NULL;
34897 }
34898
34899
34900 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34901 PyObject *resultobj;
34902 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34903 wxFrame *result;
34904 PyObject * obj0 = 0 ;
34905 char *kwnames[] = {
34906 (char *) "self", NULL
34907 };
34908
34909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34911 if (SWIG_arg_fail(1)) SWIG_fail;
34912 {
34913 PyThreadState* __tstate = wxPyBeginAllowThreads();
34914 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34915
34916 wxPyEndAllowThreads(__tstate);
34917 if (PyErr_Occurred()) SWIG_fail;
34918 }
34919 {
34920 resultobj = wxPyMake_wxObject(result, 0);
34921 }
34922 return resultobj;
34923 fail:
34924 return NULL;
34925 }
34926
34927
34928 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34929 PyObject *resultobj;
34930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34931 bool result;
34932 PyObject * obj0 = 0 ;
34933 char *kwnames[] = {
34934 (char *) "self", NULL
34935 };
34936
34937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34939 if (SWIG_arg_fail(1)) SWIG_fail;
34940 {
34941 PyThreadState* __tstate = wxPyBeginAllowThreads();
34942 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34943
34944 wxPyEndAllowThreads(__tstate);
34945 if (PyErr_Occurred()) SWIG_fail;
34946 }
34947 {
34948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34949 }
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj;
34958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34959 wxFrame *arg2 = (wxFrame *) 0 ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 char *kwnames[] = {
34963 (char *) "self",(char *) "frame", NULL
34964 };
34965
34966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
34967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34968 if (SWIG_arg_fail(1)) SWIG_fail;
34969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
34970 if (SWIG_arg_fail(2)) SWIG_fail;
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 (arg1)->Attach(arg2);
34974
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 Py_INCREF(Py_None); resultobj = Py_None;
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34986 PyObject *resultobj;
34987 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34988 PyObject * obj0 = 0 ;
34989 char *kwnames[] = {
34990 (char *) "self", NULL
34991 };
34992
34993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
34994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34995 if (SWIG_arg_fail(1)) SWIG_fail;
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 (arg1)->Detach();
34999
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 Py_INCREF(Py_None); resultobj = Py_None;
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35011 PyObject *obj;
35012 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35013 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35014 Py_INCREF(obj);
35015 return Py_BuildValue((char *)"");
35016 }
35017 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35018 PyObject *resultobj;
35019 wxMenu *arg1 = (wxMenu *) NULL ;
35020 int arg2 = (int) wxID_ANY ;
35021 wxString const &arg3_defvalue = wxPyEmptyString ;
35022 wxString *arg3 = (wxString *) &arg3_defvalue ;
35023 wxString const &arg4_defvalue = wxPyEmptyString ;
35024 wxString *arg4 = (wxString *) &arg4_defvalue ;
35025 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35026 wxMenu *arg6 = (wxMenu *) NULL ;
35027 wxMenuItem *result;
35028 bool temp3 = false ;
35029 bool temp4 = false ;
35030 PyObject * obj0 = 0 ;
35031 PyObject * obj1 = 0 ;
35032 PyObject * obj2 = 0 ;
35033 PyObject * obj3 = 0 ;
35034 PyObject * obj4 = 0 ;
35035 PyObject * obj5 = 0 ;
35036 char *kwnames[] = {
35037 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35038 };
35039
35040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35041 if (obj0) {
35042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35043 if (SWIG_arg_fail(1)) SWIG_fail;
35044 }
35045 if (obj1) {
35046 {
35047 arg2 = (int)(SWIG_As_int(obj1));
35048 if (SWIG_arg_fail(2)) SWIG_fail;
35049 }
35050 }
35051 if (obj2) {
35052 {
35053 arg3 = wxString_in_helper(obj2);
35054 if (arg3 == NULL) SWIG_fail;
35055 temp3 = true;
35056 }
35057 }
35058 if (obj3) {
35059 {
35060 arg4 = wxString_in_helper(obj3);
35061 if (arg4 == NULL) SWIG_fail;
35062 temp4 = true;
35063 }
35064 }
35065 if (obj4) {
35066 {
35067 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35068 if (SWIG_arg_fail(5)) SWIG_fail;
35069 }
35070 }
35071 if (obj5) {
35072 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35073 if (SWIG_arg_fail(6)) SWIG_fail;
35074 }
35075 {
35076 PyThreadState* __tstate = wxPyBeginAllowThreads();
35077 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35078
35079 wxPyEndAllowThreads(__tstate);
35080 if (PyErr_Occurred()) SWIG_fail;
35081 }
35082 {
35083 resultobj = wxPyMake_wxObject(result, 1);
35084 }
35085 {
35086 if (temp3)
35087 delete arg3;
35088 }
35089 {
35090 if (temp4)
35091 delete arg4;
35092 }
35093 return resultobj;
35094 fail:
35095 {
35096 if (temp3)
35097 delete arg3;
35098 }
35099 {
35100 if (temp4)
35101 delete arg4;
35102 }
35103 return NULL;
35104 }
35105
35106
35107 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj;
35109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35110 wxMenu *result;
35111 PyObject * obj0 = 0 ;
35112 char *kwnames[] = {
35113 (char *) "self", NULL
35114 };
35115
35116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35118 if (SWIG_arg_fail(1)) SWIG_fail;
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35122
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 {
35127 resultobj = wxPyMake_wxObject(result, 0);
35128 }
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35136 PyObject *resultobj;
35137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35138 wxMenu *arg2 = (wxMenu *) 0 ;
35139 PyObject * obj0 = 0 ;
35140 PyObject * obj1 = 0 ;
35141 char *kwnames[] = {
35142 (char *) "self",(char *) "menu", NULL
35143 };
35144
35145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35147 if (SWIG_arg_fail(1)) SWIG_fail;
35148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35149 if (SWIG_arg_fail(2)) SWIG_fail;
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 (arg1)->SetMenu(arg2);
35153
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 Py_INCREF(Py_None); resultobj = Py_None;
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj;
35166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35167 int arg2 ;
35168 PyObject * obj0 = 0 ;
35169 PyObject * obj1 = 0 ;
35170 char *kwnames[] = {
35171 (char *) "self",(char *) "id", NULL
35172 };
35173
35174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35176 if (SWIG_arg_fail(1)) SWIG_fail;
35177 {
35178 arg2 = (int)(SWIG_As_int(obj1));
35179 if (SWIG_arg_fail(2)) SWIG_fail;
35180 }
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 (arg1)->SetId(arg2);
35184
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 Py_INCREF(Py_None); resultobj = Py_None;
35189 return resultobj;
35190 fail:
35191 return NULL;
35192 }
35193
35194
35195 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35196 PyObject *resultobj;
35197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35198 int result;
35199 PyObject * obj0 = 0 ;
35200 char *kwnames[] = {
35201 (char *) "self", NULL
35202 };
35203
35204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35206 if (SWIG_arg_fail(1)) SWIG_fail;
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (int)((wxMenuItem const *)arg1)->GetId();
35210
35211 wxPyEndAllowThreads(__tstate);
35212 if (PyErr_Occurred()) SWIG_fail;
35213 }
35214 {
35215 resultobj = SWIG_From_int((int)(result));
35216 }
35217 return resultobj;
35218 fail:
35219 return NULL;
35220 }
35221
35222
35223 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj;
35225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35226 bool result;
35227 PyObject * obj0 = 0 ;
35228 char *kwnames[] = {
35229 (char *) "self", NULL
35230 };
35231
35232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35234 if (SWIG_arg_fail(1)) SWIG_fail;
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35238
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 {
35243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35244 }
35245 return resultobj;
35246 fail:
35247 return NULL;
35248 }
35249
35250
35251 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35252 PyObject *resultobj;
35253 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35254 wxString *arg2 = 0 ;
35255 bool temp2 = false ;
35256 PyObject * obj0 = 0 ;
35257 PyObject * obj1 = 0 ;
35258 char *kwnames[] = {
35259 (char *) "self",(char *) "str", NULL
35260 };
35261
35262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35264 if (SWIG_arg_fail(1)) SWIG_fail;
35265 {
35266 arg2 = wxString_in_helper(obj1);
35267 if (arg2 == NULL) SWIG_fail;
35268 temp2 = true;
35269 }
35270 {
35271 PyThreadState* __tstate = wxPyBeginAllowThreads();
35272 (arg1)->SetText((wxString const &)*arg2);
35273
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 Py_INCREF(Py_None); resultobj = Py_None;
35278 {
35279 if (temp2)
35280 delete arg2;
35281 }
35282 return resultobj;
35283 fail:
35284 {
35285 if (temp2)
35286 delete arg2;
35287 }
35288 return NULL;
35289 }
35290
35291
35292 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj;
35294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35295 wxString result;
35296 PyObject * obj0 = 0 ;
35297 char *kwnames[] = {
35298 (char *) "self", NULL
35299 };
35300
35301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35303 if (SWIG_arg_fail(1)) SWIG_fail;
35304 {
35305 PyThreadState* __tstate = wxPyBeginAllowThreads();
35306 result = ((wxMenuItem const *)arg1)->GetLabel();
35307
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 {
35312 #if wxUSE_UNICODE
35313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35314 #else
35315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35316 #endif
35317 }
35318 return resultobj;
35319 fail:
35320 return NULL;
35321 }
35322
35323
35324 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35325 PyObject *resultobj;
35326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35327 wxString *result;
35328 PyObject * obj0 = 0 ;
35329 char *kwnames[] = {
35330 (char *) "self", NULL
35331 };
35332
35333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35335 if (SWIG_arg_fail(1)) SWIG_fail;
35336 {
35337 PyThreadState* __tstate = wxPyBeginAllowThreads();
35338 {
35339 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35340 result = (wxString *) &_result_ref;
35341 }
35342
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 {
35347 #if wxUSE_UNICODE
35348 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35349 #else
35350 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35351 #endif
35352 }
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35360 PyObject *resultobj;
35361 wxString *arg1 = 0 ;
35362 wxString result;
35363 bool temp1 = false ;
35364 PyObject * obj0 = 0 ;
35365 char *kwnames[] = {
35366 (char *) "text", NULL
35367 };
35368
35369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35370 {
35371 arg1 = wxString_in_helper(obj0);
35372 if (arg1 == NULL) SWIG_fail;
35373 temp1 = true;
35374 }
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35378
35379 wxPyEndAllowThreads(__tstate);
35380 if (PyErr_Occurred()) SWIG_fail;
35381 }
35382 {
35383 #if wxUSE_UNICODE
35384 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35385 #else
35386 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35387 #endif
35388 }
35389 {
35390 if (temp1)
35391 delete arg1;
35392 }
35393 return resultobj;
35394 fail:
35395 {
35396 if (temp1)
35397 delete arg1;
35398 }
35399 return NULL;
35400 }
35401
35402
35403 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35404 PyObject *resultobj;
35405 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35406 wxItemKind result;
35407 PyObject * obj0 = 0 ;
35408 char *kwnames[] = {
35409 (char *) "self", NULL
35410 };
35411
35412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35414 if (SWIG_arg_fail(1)) SWIG_fail;
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35418
35419 wxPyEndAllowThreads(__tstate);
35420 if (PyErr_Occurred()) SWIG_fail;
35421 }
35422 resultobj = SWIG_From_int((result));
35423 return resultobj;
35424 fail:
35425 return NULL;
35426 }
35427
35428
35429 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35430 PyObject *resultobj;
35431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35432 wxItemKind arg2 ;
35433 PyObject * obj0 = 0 ;
35434 PyObject * obj1 = 0 ;
35435 char *kwnames[] = {
35436 (char *) "self",(char *) "kind", NULL
35437 };
35438
35439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35441 if (SWIG_arg_fail(1)) SWIG_fail;
35442 {
35443 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35444 if (SWIG_arg_fail(2)) SWIG_fail;
35445 }
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 (arg1)->SetKind((wxItemKind )arg2);
35449
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 Py_INCREF(Py_None); resultobj = Py_None;
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj;
35462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35463 bool arg2 ;
35464 PyObject * obj0 = 0 ;
35465 PyObject * obj1 = 0 ;
35466 char *kwnames[] = {
35467 (char *) "self",(char *) "checkable", NULL
35468 };
35469
35470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35472 if (SWIG_arg_fail(1)) SWIG_fail;
35473 {
35474 arg2 = (bool)(SWIG_As_bool(obj1));
35475 if (SWIG_arg_fail(2)) SWIG_fail;
35476 }
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 (arg1)->SetCheckable(arg2);
35480
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 Py_INCREF(Py_None); resultobj = Py_None;
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj;
35493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35494 bool result;
35495 PyObject * obj0 = 0 ;
35496 char *kwnames[] = {
35497 (char *) "self", NULL
35498 };
35499
35500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35502 if (SWIG_arg_fail(1)) SWIG_fail;
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35506
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 {
35511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35512 }
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj;
35521 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35522 bool result;
35523 PyObject * obj0 = 0 ;
35524 char *kwnames[] = {
35525 (char *) "self", NULL
35526 };
35527
35528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35530 if (SWIG_arg_fail(1)) SWIG_fail;
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35534
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 {
35539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35540 }
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj;
35549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35550 wxMenu *arg2 = (wxMenu *) 0 ;
35551 PyObject * obj0 = 0 ;
35552 PyObject * obj1 = 0 ;
35553 char *kwnames[] = {
35554 (char *) "self",(char *) "menu", NULL
35555 };
35556
35557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35559 if (SWIG_arg_fail(1)) SWIG_fail;
35560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35561 if (SWIG_arg_fail(2)) SWIG_fail;
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 (arg1)->SetSubMenu(arg2);
35565
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 Py_INCREF(Py_None); resultobj = Py_None;
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35577 PyObject *resultobj;
35578 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35579 wxMenu *result;
35580 PyObject * obj0 = 0 ;
35581 char *kwnames[] = {
35582 (char *) "self", NULL
35583 };
35584
35585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35587 if (SWIG_arg_fail(1)) SWIG_fail;
35588 {
35589 PyThreadState* __tstate = wxPyBeginAllowThreads();
35590 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35591
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 {
35596 resultobj = wxPyMake_wxObject(result, 0);
35597 }
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35605 PyObject *resultobj;
35606 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35607 bool arg2 = (bool) true ;
35608 PyObject * obj0 = 0 ;
35609 PyObject * obj1 = 0 ;
35610 char *kwnames[] = {
35611 (char *) "self",(char *) "enable", NULL
35612 };
35613
35614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35616 if (SWIG_arg_fail(1)) SWIG_fail;
35617 if (obj1) {
35618 {
35619 arg2 = (bool)(SWIG_As_bool(obj1));
35620 if (SWIG_arg_fail(2)) SWIG_fail;
35621 }
35622 }
35623 {
35624 PyThreadState* __tstate = wxPyBeginAllowThreads();
35625 (arg1)->Enable(arg2);
35626
35627 wxPyEndAllowThreads(__tstate);
35628 if (PyErr_Occurred()) SWIG_fail;
35629 }
35630 Py_INCREF(Py_None); resultobj = Py_None;
35631 return resultobj;
35632 fail:
35633 return NULL;
35634 }
35635
35636
35637 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35638 PyObject *resultobj;
35639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35640 bool result;
35641 PyObject * obj0 = 0 ;
35642 char *kwnames[] = {
35643 (char *) "self", NULL
35644 };
35645
35646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35648 if (SWIG_arg_fail(1)) SWIG_fail;
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35652
35653 wxPyEndAllowThreads(__tstate);
35654 if (PyErr_Occurred()) SWIG_fail;
35655 }
35656 {
35657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35658 }
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj;
35667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35668 bool arg2 = (bool) true ;
35669 PyObject * obj0 = 0 ;
35670 PyObject * obj1 = 0 ;
35671 char *kwnames[] = {
35672 (char *) "self",(char *) "check", NULL
35673 };
35674
35675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35677 if (SWIG_arg_fail(1)) SWIG_fail;
35678 if (obj1) {
35679 {
35680 arg2 = (bool)(SWIG_As_bool(obj1));
35681 if (SWIG_arg_fail(2)) SWIG_fail;
35682 }
35683 }
35684 {
35685 PyThreadState* __tstate = wxPyBeginAllowThreads();
35686 (arg1)->Check(arg2);
35687
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 Py_INCREF(Py_None); resultobj = Py_None;
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj;
35700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35701 bool result;
35702 PyObject * obj0 = 0 ;
35703 char *kwnames[] = {
35704 (char *) "self", NULL
35705 };
35706
35707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35709 if (SWIG_arg_fail(1)) SWIG_fail;
35710 {
35711 PyThreadState* __tstate = wxPyBeginAllowThreads();
35712 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35713
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 {
35718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35719 }
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj;
35728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35729 PyObject * obj0 = 0 ;
35730 char *kwnames[] = {
35731 (char *) "self", NULL
35732 };
35733
35734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35736 if (SWIG_arg_fail(1)) SWIG_fail;
35737 {
35738 PyThreadState* __tstate = wxPyBeginAllowThreads();
35739 (arg1)->Toggle();
35740
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 Py_INCREF(Py_None); resultobj = Py_None;
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35752 PyObject *resultobj;
35753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35754 wxString *arg2 = 0 ;
35755 bool temp2 = false ;
35756 PyObject * obj0 = 0 ;
35757 PyObject * obj1 = 0 ;
35758 char *kwnames[] = {
35759 (char *) "self",(char *) "str", NULL
35760 };
35761
35762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35764 if (SWIG_arg_fail(1)) SWIG_fail;
35765 {
35766 arg2 = wxString_in_helper(obj1);
35767 if (arg2 == NULL) SWIG_fail;
35768 temp2 = true;
35769 }
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 (arg1)->SetHelp((wxString const &)*arg2);
35773
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 Py_INCREF(Py_None); resultobj = Py_None;
35778 {
35779 if (temp2)
35780 delete arg2;
35781 }
35782 return resultobj;
35783 fail:
35784 {
35785 if (temp2)
35786 delete arg2;
35787 }
35788 return NULL;
35789 }
35790
35791
35792 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35793 PyObject *resultobj;
35794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35795 wxString *result;
35796 PyObject * obj0 = 0 ;
35797 char *kwnames[] = {
35798 (char *) "self", NULL
35799 };
35800
35801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35803 if (SWIG_arg_fail(1)) SWIG_fail;
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 {
35807 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35808 result = (wxString *) &_result_ref;
35809 }
35810
35811 wxPyEndAllowThreads(__tstate);
35812 if (PyErr_Occurred()) SWIG_fail;
35813 }
35814 {
35815 #if wxUSE_UNICODE
35816 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35817 #else
35818 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35819 #endif
35820 }
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35828 PyObject *resultobj;
35829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35830 wxAcceleratorEntry *result;
35831 PyObject * obj0 = 0 ;
35832 char *kwnames[] = {
35833 (char *) "self", NULL
35834 };
35835
35836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35838 if (SWIG_arg_fail(1)) SWIG_fail;
35839 {
35840 PyThreadState* __tstate = wxPyBeginAllowThreads();
35841 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35842
35843 wxPyEndAllowThreads(__tstate);
35844 if (PyErr_Occurred()) SWIG_fail;
35845 }
35846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35847 return resultobj;
35848 fail:
35849 return NULL;
35850 }
35851
35852
35853 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35854 PyObject *resultobj;
35855 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35856 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35857 PyObject * obj0 = 0 ;
35858 PyObject * obj1 = 0 ;
35859 char *kwnames[] = {
35860 (char *) "self",(char *) "accel", NULL
35861 };
35862
35863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(1)) SWIG_fail;
35866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35867 if (SWIG_arg_fail(2)) SWIG_fail;
35868 {
35869 PyThreadState* __tstate = wxPyBeginAllowThreads();
35870 (arg1)->SetAccel(arg2);
35871
35872 wxPyEndAllowThreads(__tstate);
35873 if (PyErr_Occurred()) SWIG_fail;
35874 }
35875 Py_INCREF(Py_None); resultobj = Py_None;
35876 return resultobj;
35877 fail:
35878 return NULL;
35879 }
35880
35881
35882 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35883 PyObject *resultobj;
35884 int result;
35885 char *kwnames[] = {
35886 NULL
35887 };
35888
35889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 result = (int)MenuItem_GetDefaultMarginWidth();
35893
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 {
35898 resultobj = SWIG_From_int((int)(result));
35899 }
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj;
35908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35909 wxBitmap *arg2 = 0 ;
35910 PyObject * obj0 = 0 ;
35911 PyObject * obj1 = 0 ;
35912 char *kwnames[] = {
35913 (char *) "self",(char *) "bitmap", NULL
35914 };
35915
35916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35918 if (SWIG_arg_fail(1)) SWIG_fail;
35919 {
35920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35921 if (SWIG_arg_fail(2)) SWIG_fail;
35922 if (arg2 == NULL) {
35923 SWIG_null_ref("wxBitmap");
35924 }
35925 if (SWIG_arg_fail(2)) SWIG_fail;
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35930
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 Py_INCREF(Py_None); resultobj = Py_None;
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35942 PyObject *resultobj;
35943 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35944 wxBitmap *result;
35945 PyObject * obj0 = 0 ;
35946 char *kwnames[] = {
35947 (char *) "self", NULL
35948 };
35949
35950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
35951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35952 if (SWIG_arg_fail(1)) SWIG_fail;
35953 {
35954 PyThreadState* __tstate = wxPyBeginAllowThreads();
35955 {
35956 wxBitmap const &_result_ref = (arg1)->GetBitmap();
35957 result = (wxBitmap *) &_result_ref;
35958 }
35959
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 {
35964 wxBitmap* resultptr = new wxBitmap(*result);
35965 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
35966 }
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
35974 PyObject *obj;
35975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35976 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
35977 Py_INCREF(obj);
35978 return Py_BuildValue((char *)"");
35979 }
35980 static int _wrap_ControlNameStr_set(PyObject *) {
35981 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
35982 return 1;
35983 }
35984
35985
35986 static PyObject *_wrap_ControlNameStr_get(void) {
35987 PyObject *pyobj;
35988
35989 {
35990 #if wxUSE_UNICODE
35991 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35992 #else
35993 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35994 #endif
35995 }
35996 return pyobj;
35997 }
35998
35999
36000 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36001 PyObject *resultobj;
36002 wxWindow *arg1 = (wxWindow *) 0 ;
36003 int arg2 = (int) -1 ;
36004 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36005 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36006 wxSize const &arg4_defvalue = wxDefaultSize ;
36007 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36008 long arg5 = (long) 0 ;
36009 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36010 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36011 wxString const &arg7_defvalue = wxPyControlNameStr ;
36012 wxString *arg7 = (wxString *) &arg7_defvalue ;
36013 wxControl *result;
36014 wxPoint temp3 ;
36015 wxSize temp4 ;
36016 bool temp7 = false ;
36017 PyObject * obj0 = 0 ;
36018 PyObject * obj1 = 0 ;
36019 PyObject * obj2 = 0 ;
36020 PyObject * obj3 = 0 ;
36021 PyObject * obj4 = 0 ;
36022 PyObject * obj5 = 0 ;
36023 PyObject * obj6 = 0 ;
36024 char *kwnames[] = {
36025 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36026 };
36027
36028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36030 if (SWIG_arg_fail(1)) SWIG_fail;
36031 if (obj1) {
36032 {
36033 arg2 = (int)(SWIG_As_int(obj1));
36034 if (SWIG_arg_fail(2)) SWIG_fail;
36035 }
36036 }
36037 if (obj2) {
36038 {
36039 arg3 = &temp3;
36040 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36041 }
36042 }
36043 if (obj3) {
36044 {
36045 arg4 = &temp4;
36046 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36047 }
36048 }
36049 if (obj4) {
36050 {
36051 arg5 = (long)(SWIG_As_long(obj4));
36052 if (SWIG_arg_fail(5)) SWIG_fail;
36053 }
36054 }
36055 if (obj5) {
36056 {
36057 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(6)) SWIG_fail;
36059 if (arg6 == NULL) {
36060 SWIG_null_ref("wxValidator");
36061 }
36062 if (SWIG_arg_fail(6)) SWIG_fail;
36063 }
36064 }
36065 if (obj6) {
36066 {
36067 arg7 = wxString_in_helper(obj6);
36068 if (arg7 == NULL) SWIG_fail;
36069 temp7 = true;
36070 }
36071 }
36072 {
36073 if (!wxPyCheckForApp()) SWIG_fail;
36074 PyThreadState* __tstate = wxPyBeginAllowThreads();
36075 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36076
36077 wxPyEndAllowThreads(__tstate);
36078 if (PyErr_Occurred()) SWIG_fail;
36079 }
36080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36081 {
36082 if (temp7)
36083 delete arg7;
36084 }
36085 return resultobj;
36086 fail:
36087 {
36088 if (temp7)
36089 delete arg7;
36090 }
36091 return NULL;
36092 }
36093
36094
36095 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36096 PyObject *resultobj;
36097 wxControl *result;
36098 char *kwnames[] = {
36099 NULL
36100 };
36101
36102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36103 {
36104 if (!wxPyCheckForApp()) SWIG_fail;
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 result = (wxControl *)new wxControl();
36107
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36119 PyObject *resultobj;
36120 wxControl *arg1 = (wxControl *) 0 ;
36121 wxWindow *arg2 = (wxWindow *) 0 ;
36122 int arg3 = (int) -1 ;
36123 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36124 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36125 wxSize const &arg5_defvalue = wxDefaultSize ;
36126 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36127 long arg6 = (long) 0 ;
36128 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36129 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36130 wxString const &arg8_defvalue = wxPyControlNameStr ;
36131 wxString *arg8 = (wxString *) &arg8_defvalue ;
36132 bool result;
36133 wxPoint temp4 ;
36134 wxSize temp5 ;
36135 bool temp8 = false ;
36136 PyObject * obj0 = 0 ;
36137 PyObject * obj1 = 0 ;
36138 PyObject * obj2 = 0 ;
36139 PyObject * obj3 = 0 ;
36140 PyObject * obj4 = 0 ;
36141 PyObject * obj5 = 0 ;
36142 PyObject * obj6 = 0 ;
36143 PyObject * obj7 = 0 ;
36144 char *kwnames[] = {
36145 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36146 };
36147
36148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(1)) SWIG_fail;
36151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36152 if (SWIG_arg_fail(2)) SWIG_fail;
36153 if (obj2) {
36154 {
36155 arg3 = (int)(SWIG_As_int(obj2));
36156 if (SWIG_arg_fail(3)) SWIG_fail;
36157 }
36158 }
36159 if (obj3) {
36160 {
36161 arg4 = &temp4;
36162 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36163 }
36164 }
36165 if (obj4) {
36166 {
36167 arg5 = &temp5;
36168 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36169 }
36170 }
36171 if (obj5) {
36172 {
36173 arg6 = (long)(SWIG_As_long(obj5));
36174 if (SWIG_arg_fail(6)) SWIG_fail;
36175 }
36176 }
36177 if (obj6) {
36178 {
36179 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36180 if (SWIG_arg_fail(7)) SWIG_fail;
36181 if (arg7 == NULL) {
36182 SWIG_null_ref("wxValidator");
36183 }
36184 if (SWIG_arg_fail(7)) SWIG_fail;
36185 }
36186 }
36187 if (obj7) {
36188 {
36189 arg8 = wxString_in_helper(obj7);
36190 if (arg8 == NULL) SWIG_fail;
36191 temp8 = true;
36192 }
36193 }
36194 {
36195 PyThreadState* __tstate = wxPyBeginAllowThreads();
36196 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36197
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 {
36202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36203 }
36204 {
36205 if (temp8)
36206 delete arg8;
36207 }
36208 return resultobj;
36209 fail:
36210 {
36211 if (temp8)
36212 delete arg8;
36213 }
36214 return NULL;
36215 }
36216
36217
36218 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36219 PyObject *resultobj;
36220 wxControl *arg1 = (wxControl *) 0 ;
36221 wxCommandEvent *arg2 = 0 ;
36222 PyObject * obj0 = 0 ;
36223 PyObject * obj1 = 0 ;
36224 char *kwnames[] = {
36225 (char *) "self",(char *) "event", NULL
36226 };
36227
36228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36230 if (SWIG_arg_fail(1)) SWIG_fail;
36231 {
36232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36233 if (SWIG_arg_fail(2)) SWIG_fail;
36234 if (arg2 == NULL) {
36235 SWIG_null_ref("wxCommandEvent");
36236 }
36237 if (SWIG_arg_fail(2)) SWIG_fail;
36238 }
36239 {
36240 PyThreadState* __tstate = wxPyBeginAllowThreads();
36241 (arg1)->Command(*arg2);
36242
36243 wxPyEndAllowThreads(__tstate);
36244 if (PyErr_Occurred()) SWIG_fail;
36245 }
36246 Py_INCREF(Py_None); resultobj = Py_None;
36247 return resultobj;
36248 fail:
36249 return NULL;
36250 }
36251
36252
36253 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36254 PyObject *resultobj;
36255 wxControl *arg1 = (wxControl *) 0 ;
36256 wxString result;
36257 PyObject * obj0 = 0 ;
36258 char *kwnames[] = {
36259 (char *) "self", NULL
36260 };
36261
36262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36264 if (SWIG_arg_fail(1)) SWIG_fail;
36265 {
36266 PyThreadState* __tstate = wxPyBeginAllowThreads();
36267 result = (arg1)->GetLabel();
36268
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 {
36273 #if wxUSE_UNICODE
36274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36275 #else
36276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36277 #endif
36278 }
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxControl *arg1 = (wxControl *) 0 ;
36288 wxString *arg2 = 0 ;
36289 bool temp2 = false ;
36290 PyObject * obj0 = 0 ;
36291 PyObject * obj1 = 0 ;
36292 char *kwnames[] = {
36293 (char *) "self",(char *) "label", NULL
36294 };
36295
36296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36298 if (SWIG_arg_fail(1)) SWIG_fail;
36299 {
36300 arg2 = wxString_in_helper(obj1);
36301 if (arg2 == NULL) SWIG_fail;
36302 temp2 = true;
36303 }
36304 {
36305 PyThreadState* __tstate = wxPyBeginAllowThreads();
36306 (arg1)->SetLabel((wxString const &)*arg2);
36307
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 Py_INCREF(Py_None); resultobj = Py_None;
36312 {
36313 if (temp2)
36314 delete arg2;
36315 }
36316 return resultobj;
36317 fail:
36318 {
36319 if (temp2)
36320 delete arg2;
36321 }
36322 return NULL;
36323 }
36324
36325
36326 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36327 PyObject *resultobj;
36328 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36329 wxVisualAttributes result;
36330 PyObject * obj0 = 0 ;
36331 char *kwnames[] = {
36332 (char *) "variant", NULL
36333 };
36334
36335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36336 if (obj0) {
36337 {
36338 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36339 if (SWIG_arg_fail(1)) SWIG_fail;
36340 }
36341 }
36342 {
36343 if (!wxPyCheckForApp()) SWIG_fail;
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36346
36347 wxPyEndAllowThreads(__tstate);
36348 if (PyErr_Occurred()) SWIG_fail;
36349 }
36350 {
36351 wxVisualAttributes * resultptr;
36352 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36362 PyObject *obj;
36363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36364 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36365 Py_INCREF(obj);
36366 return Py_BuildValue((char *)"");
36367 }
36368 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36369 PyObject *resultobj;
36370 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36371 wxString *arg2 = 0 ;
36372 PyObject *arg3 = (PyObject *) NULL ;
36373 int result;
36374 bool temp2 = false ;
36375 PyObject * obj0 = 0 ;
36376 PyObject * obj1 = 0 ;
36377 PyObject * obj2 = 0 ;
36378 char *kwnames[] = {
36379 (char *) "self",(char *) "item",(char *) "clientData", NULL
36380 };
36381
36382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36384 if (SWIG_arg_fail(1)) SWIG_fail;
36385 {
36386 arg2 = wxString_in_helper(obj1);
36387 if (arg2 == NULL) SWIG_fail;
36388 temp2 = true;
36389 }
36390 if (obj2) {
36391 arg3 = obj2;
36392 }
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36396
36397 wxPyEndAllowThreads(__tstate);
36398 if (PyErr_Occurred()) SWIG_fail;
36399 }
36400 {
36401 resultobj = SWIG_From_int((int)(result));
36402 }
36403 {
36404 if (temp2)
36405 delete arg2;
36406 }
36407 return resultobj;
36408 fail:
36409 {
36410 if (temp2)
36411 delete arg2;
36412 }
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36420 wxArrayString *arg2 = 0 ;
36421 bool temp2 = false ;
36422 PyObject * obj0 = 0 ;
36423 PyObject * obj1 = 0 ;
36424 char *kwnames[] = {
36425 (char *) "self",(char *) "strings", NULL
36426 };
36427
36428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36430 if (SWIG_arg_fail(1)) SWIG_fail;
36431 {
36432 if (! PySequence_Check(obj1)) {
36433 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36434 SWIG_fail;
36435 }
36436 arg2 = new wxArrayString;
36437 temp2 = true;
36438 int i, len=PySequence_Length(obj1);
36439 for (i=0; i<len; i++) {
36440 PyObject* item = PySequence_GetItem(obj1, i);
36441 #if wxUSE_UNICODE
36442 PyObject* str = PyObject_Unicode(item);
36443 #else
36444 PyObject* str = PyObject_Str(item);
36445 #endif
36446 if (PyErr_Occurred()) SWIG_fail;
36447 arg2->Add(Py2wxString(str));
36448 Py_DECREF(item);
36449 Py_DECREF(str);
36450 }
36451 }
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 (arg1)->Append((wxArrayString const &)*arg2);
36455
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 Py_INCREF(Py_None); resultobj = Py_None;
36460 {
36461 if (temp2) delete arg2;
36462 }
36463 return resultobj;
36464 fail:
36465 {
36466 if (temp2) delete arg2;
36467 }
36468 return NULL;
36469 }
36470
36471
36472 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36473 PyObject *resultobj;
36474 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36475 wxString *arg2 = 0 ;
36476 int arg3 ;
36477 PyObject *arg4 = (PyObject *) NULL ;
36478 int result;
36479 bool temp2 = false ;
36480 PyObject * obj0 = 0 ;
36481 PyObject * obj1 = 0 ;
36482 PyObject * obj2 = 0 ;
36483 PyObject * obj3 = 0 ;
36484 char *kwnames[] = {
36485 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36486 };
36487
36488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36490 if (SWIG_arg_fail(1)) SWIG_fail;
36491 {
36492 arg2 = wxString_in_helper(obj1);
36493 if (arg2 == NULL) SWIG_fail;
36494 temp2 = true;
36495 }
36496 {
36497 arg3 = (int)(SWIG_As_int(obj2));
36498 if (SWIG_arg_fail(3)) SWIG_fail;
36499 }
36500 if (obj3) {
36501 arg4 = obj3;
36502 }
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36506
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 {
36511 resultobj = SWIG_From_int((int)(result));
36512 }
36513 {
36514 if (temp2)
36515 delete arg2;
36516 }
36517 return resultobj;
36518 fail:
36519 {
36520 if (temp2)
36521 delete arg2;
36522 }
36523 return NULL;
36524 }
36525
36526
36527 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36528 PyObject *resultobj;
36529 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36530 PyObject * obj0 = 0 ;
36531 char *kwnames[] = {
36532 (char *) "self", NULL
36533 };
36534
36535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36537 if (SWIG_arg_fail(1)) SWIG_fail;
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 (arg1)->Clear();
36541
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 Py_INCREF(Py_None); resultobj = Py_None;
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj;
36554 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36555 int arg2 ;
36556 PyObject * obj0 = 0 ;
36557 PyObject * obj1 = 0 ;
36558 char *kwnames[] = {
36559 (char *) "self",(char *) "n", NULL
36560 };
36561
36562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36564 if (SWIG_arg_fail(1)) SWIG_fail;
36565 {
36566 arg2 = (int)(SWIG_As_int(obj1));
36567 if (SWIG_arg_fail(2)) SWIG_fail;
36568 }
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 (arg1)->Delete(arg2);
36572
36573 wxPyEndAllowThreads(__tstate);
36574 if (PyErr_Occurred()) SWIG_fail;
36575 }
36576 Py_INCREF(Py_None); resultobj = Py_None;
36577 return resultobj;
36578 fail:
36579 return NULL;
36580 }
36581
36582
36583 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36584 PyObject *resultobj;
36585 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36586 int result;
36587 PyObject * obj0 = 0 ;
36588 char *kwnames[] = {
36589 (char *) "self", NULL
36590 };
36591
36592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36594 if (SWIG_arg_fail(1)) SWIG_fail;
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = (int)((wxItemContainer const *)arg1)->GetCount();
36598
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 {
36603 resultobj = SWIG_From_int((int)(result));
36604 }
36605 return resultobj;
36606 fail:
36607 return NULL;
36608 }
36609
36610
36611 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36612 PyObject *resultobj;
36613 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36614 bool result;
36615 PyObject * obj0 = 0 ;
36616 char *kwnames[] = {
36617 (char *) "self", NULL
36618 };
36619
36620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36622 if (SWIG_arg_fail(1)) SWIG_fail;
36623 {
36624 PyThreadState* __tstate = wxPyBeginAllowThreads();
36625 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36626
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36632 }
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36640 PyObject *resultobj;
36641 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36642 int arg2 ;
36643 wxString result;
36644 PyObject * obj0 = 0 ;
36645 PyObject * obj1 = 0 ;
36646 char *kwnames[] = {
36647 (char *) "self",(char *) "n", NULL
36648 };
36649
36650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36652 if (SWIG_arg_fail(1)) SWIG_fail;
36653 {
36654 arg2 = (int)(SWIG_As_int(obj1));
36655 if (SWIG_arg_fail(2)) SWIG_fail;
36656 }
36657 {
36658 PyThreadState* __tstate = wxPyBeginAllowThreads();
36659 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36660
36661 wxPyEndAllowThreads(__tstate);
36662 if (PyErr_Occurred()) SWIG_fail;
36663 }
36664 {
36665 #if wxUSE_UNICODE
36666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36667 #else
36668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36669 #endif
36670 }
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj;
36679 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36680 wxArrayString result;
36681 PyObject * obj0 = 0 ;
36682 char *kwnames[] = {
36683 (char *) "self", NULL
36684 };
36685
36686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36688 if (SWIG_arg_fail(1)) SWIG_fail;
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 result = ((wxItemContainer const *)arg1)->GetStrings();
36692
36693 wxPyEndAllowThreads(__tstate);
36694 if (PyErr_Occurred()) SWIG_fail;
36695 }
36696 {
36697 resultobj = wxArrayString2PyList_helper(result);
36698 }
36699 return resultobj;
36700 fail:
36701 return NULL;
36702 }
36703
36704
36705 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36706 PyObject *resultobj;
36707 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36708 int arg2 ;
36709 wxString *arg3 = 0 ;
36710 bool temp3 = false ;
36711 PyObject * obj0 = 0 ;
36712 PyObject * obj1 = 0 ;
36713 PyObject * obj2 = 0 ;
36714 char *kwnames[] = {
36715 (char *) "self",(char *) "n",(char *) "s", NULL
36716 };
36717
36718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36720 if (SWIG_arg_fail(1)) SWIG_fail;
36721 {
36722 arg2 = (int)(SWIG_As_int(obj1));
36723 if (SWIG_arg_fail(2)) SWIG_fail;
36724 }
36725 {
36726 arg3 = wxString_in_helper(obj2);
36727 if (arg3 == NULL) SWIG_fail;
36728 temp3 = true;
36729 }
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 (arg1)->SetString(arg2,(wxString const &)*arg3);
36733
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 Py_INCREF(Py_None); resultobj = Py_None;
36738 {
36739 if (temp3)
36740 delete arg3;
36741 }
36742 return resultobj;
36743 fail:
36744 {
36745 if (temp3)
36746 delete arg3;
36747 }
36748 return NULL;
36749 }
36750
36751
36752 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36753 PyObject *resultobj;
36754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36755 wxString *arg2 = 0 ;
36756 int result;
36757 bool temp2 = false ;
36758 PyObject * obj0 = 0 ;
36759 PyObject * obj1 = 0 ;
36760 char *kwnames[] = {
36761 (char *) "self",(char *) "s", NULL
36762 };
36763
36764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36766 if (SWIG_arg_fail(1)) SWIG_fail;
36767 {
36768 arg2 = wxString_in_helper(obj1);
36769 if (arg2 == NULL) SWIG_fail;
36770 temp2 = true;
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36775
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 {
36780 resultobj = SWIG_From_int((int)(result));
36781 }
36782 {
36783 if (temp2)
36784 delete arg2;
36785 }
36786 return resultobj;
36787 fail:
36788 {
36789 if (temp2)
36790 delete arg2;
36791 }
36792 return NULL;
36793 }
36794
36795
36796 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj;
36798 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36799 int arg2 ;
36800 PyObject * obj0 = 0 ;
36801 PyObject * obj1 = 0 ;
36802 char *kwnames[] = {
36803 (char *) "self",(char *) "n", NULL
36804 };
36805
36806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
36807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36808 if (SWIG_arg_fail(1)) SWIG_fail;
36809 {
36810 arg2 = (int)(SWIG_As_int(obj1));
36811 if (SWIG_arg_fail(2)) SWIG_fail;
36812 }
36813 {
36814 PyThreadState* __tstate = wxPyBeginAllowThreads();
36815 (arg1)->Select(arg2);
36816
36817 wxPyEndAllowThreads(__tstate);
36818 if (PyErr_Occurred()) SWIG_fail;
36819 }
36820 Py_INCREF(Py_None); resultobj = Py_None;
36821 return resultobj;
36822 fail:
36823 return NULL;
36824 }
36825
36826
36827 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36828 PyObject *resultobj;
36829 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36830 int result;
36831 PyObject * obj0 = 0 ;
36832 char *kwnames[] = {
36833 (char *) "self", NULL
36834 };
36835
36836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36838 if (SWIG_arg_fail(1)) SWIG_fail;
36839 {
36840 PyThreadState* __tstate = wxPyBeginAllowThreads();
36841 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36842
36843 wxPyEndAllowThreads(__tstate);
36844 if (PyErr_Occurred()) SWIG_fail;
36845 }
36846 {
36847 resultobj = SWIG_From_int((int)(result));
36848 }
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36856 PyObject *resultobj;
36857 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36858 wxString result;
36859 PyObject * obj0 = 0 ;
36860 char *kwnames[] = {
36861 (char *) "self", NULL
36862 };
36863
36864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
36865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36866 if (SWIG_arg_fail(1)) SWIG_fail;
36867 {
36868 PyThreadState* __tstate = wxPyBeginAllowThreads();
36869 result = ((wxItemContainer const *)arg1)->GetStringSelection();
36870
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 #if wxUSE_UNICODE
36876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36877 #else
36878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36879 #endif
36880 }
36881 return resultobj;
36882 fail:
36883 return NULL;
36884 }
36885
36886
36887 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36888 PyObject *resultobj;
36889 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36890 int arg2 ;
36891 PyObject *result;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char *kwnames[] = {
36895 (char *) "self",(char *) "n", NULL
36896 };
36897
36898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36900 if (SWIG_arg_fail(1)) SWIG_fail;
36901 {
36902 arg2 = (int)(SWIG_As_int(obj1));
36903 if (SWIG_arg_fail(2)) SWIG_fail;
36904 }
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 resultobj = result;
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj;
36921 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36922 int arg2 ;
36923 PyObject *arg3 = (PyObject *) 0 ;
36924 PyObject * obj0 = 0 ;
36925 PyObject * obj1 = 0 ;
36926 PyObject * obj2 = 0 ;
36927 char *kwnames[] = {
36928 (char *) "self",(char *) "n",(char *) "clientData", NULL
36929 };
36930
36931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36933 if (SWIG_arg_fail(1)) SWIG_fail;
36934 {
36935 arg2 = (int)(SWIG_As_int(obj1));
36936 if (SWIG_arg_fail(2)) SWIG_fail;
36937 }
36938 arg3 = obj2;
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 wxItemContainer_SetClientData(arg1,arg2,arg3);
36942
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 Py_INCREF(Py_None); resultobj = Py_None;
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
36954 PyObject *obj;
36955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36956 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
36957 Py_INCREF(obj);
36958 return Py_BuildValue((char *)"");
36959 }
36960 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
36961 PyObject *obj;
36962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36963 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
36964 Py_INCREF(obj);
36965 return Py_BuildValue((char *)"");
36966 }
36967 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj;
36969 wxSizerItem *result;
36970 char *kwnames[] = {
36971 NULL
36972 };
36973
36974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
36975 {
36976 PyThreadState* __tstate = wxPyBeginAllowThreads();
36977 result = (wxSizerItem *)new wxSizerItem();
36978
36979 wxPyEndAllowThreads(__tstate);
36980 if (PyErr_Occurred()) SWIG_fail;
36981 }
36982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36983 return resultobj;
36984 fail:
36985 return NULL;
36986 }
36987
36988
36989 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
36990 PyObject *resultobj;
36991 wxWindow *arg1 = (wxWindow *) 0 ;
36992 int arg2 ;
36993 int arg3 ;
36994 int arg4 ;
36995 PyObject *arg5 = (PyObject *) NULL ;
36996 wxSizerItem *result;
36997 PyObject * obj0 = 0 ;
36998 PyObject * obj1 = 0 ;
36999 PyObject * obj2 = 0 ;
37000 PyObject * obj3 = 0 ;
37001 PyObject * obj4 = 0 ;
37002 char *kwnames[] = {
37003 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37004 };
37005
37006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37008 if (SWIG_arg_fail(1)) SWIG_fail;
37009 {
37010 arg2 = (int)(SWIG_As_int(obj1));
37011 if (SWIG_arg_fail(2)) SWIG_fail;
37012 }
37013 {
37014 arg3 = (int)(SWIG_As_int(obj2));
37015 if (SWIG_arg_fail(3)) SWIG_fail;
37016 }
37017 {
37018 arg4 = (int)(SWIG_As_int(obj3));
37019 if (SWIG_arg_fail(4)) SWIG_fail;
37020 }
37021 if (obj4) {
37022 arg5 = obj4;
37023 }
37024 {
37025 PyThreadState* __tstate = wxPyBeginAllowThreads();
37026 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37027
37028 wxPyEndAllowThreads(__tstate);
37029 if (PyErr_Occurred()) SWIG_fail;
37030 }
37031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37032 return resultobj;
37033 fail:
37034 return NULL;
37035 }
37036
37037
37038 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37039 PyObject *resultobj;
37040 int arg1 ;
37041 int arg2 ;
37042 int arg3 ;
37043 int arg4 ;
37044 int arg5 ;
37045 PyObject *arg6 = (PyObject *) NULL ;
37046 wxSizerItem *result;
37047 PyObject * obj0 = 0 ;
37048 PyObject * obj1 = 0 ;
37049 PyObject * obj2 = 0 ;
37050 PyObject * obj3 = 0 ;
37051 PyObject * obj4 = 0 ;
37052 PyObject * obj5 = 0 ;
37053 char *kwnames[] = {
37054 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37055 };
37056
37057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37058 {
37059 arg1 = (int)(SWIG_As_int(obj0));
37060 if (SWIG_arg_fail(1)) SWIG_fail;
37061 }
37062 {
37063 arg2 = (int)(SWIG_As_int(obj1));
37064 if (SWIG_arg_fail(2)) SWIG_fail;
37065 }
37066 {
37067 arg3 = (int)(SWIG_As_int(obj2));
37068 if (SWIG_arg_fail(3)) SWIG_fail;
37069 }
37070 {
37071 arg4 = (int)(SWIG_As_int(obj3));
37072 if (SWIG_arg_fail(4)) SWIG_fail;
37073 }
37074 {
37075 arg5 = (int)(SWIG_As_int(obj4));
37076 if (SWIG_arg_fail(5)) SWIG_fail;
37077 }
37078 if (obj5) {
37079 arg6 = obj5;
37080 }
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37084
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj;
37097 wxSizer *arg1 = (wxSizer *) 0 ;
37098 int arg2 ;
37099 int arg3 ;
37100 int arg4 ;
37101 PyObject *arg5 = (PyObject *) NULL ;
37102 wxSizerItem *result;
37103 PyObject * obj0 = 0 ;
37104 PyObject * obj1 = 0 ;
37105 PyObject * obj2 = 0 ;
37106 PyObject * obj3 = 0 ;
37107 PyObject * obj4 = 0 ;
37108 char *kwnames[] = {
37109 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37110 };
37111
37112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37114 if (SWIG_arg_fail(1)) SWIG_fail;
37115 {
37116 arg2 = (int)(SWIG_As_int(obj1));
37117 if (SWIG_arg_fail(2)) SWIG_fail;
37118 }
37119 {
37120 arg3 = (int)(SWIG_As_int(obj2));
37121 if (SWIG_arg_fail(3)) SWIG_fail;
37122 }
37123 {
37124 arg4 = (int)(SWIG_As_int(obj3));
37125 if (SWIG_arg_fail(4)) SWIG_fail;
37126 }
37127 if (obj4) {
37128 arg5 = obj4;
37129 }
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37133
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37145 PyObject *resultobj;
37146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37147 PyObject * obj0 = 0 ;
37148 char *kwnames[] = {
37149 (char *) "self", NULL
37150 };
37151
37152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37154 if (SWIG_arg_fail(1)) SWIG_fail;
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 (arg1)->DeleteWindows();
37158
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 Py_INCREF(Py_None); resultobj = Py_None;
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj;
37171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37172 PyObject * obj0 = 0 ;
37173 char *kwnames[] = {
37174 (char *) "self", NULL
37175 };
37176
37177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37179 if (SWIG_arg_fail(1)) SWIG_fail;
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 (arg1)->DetachSizer();
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 Py_INCREF(Py_None); resultobj = Py_None;
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37195 PyObject *resultobj;
37196 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37197 wxSize result;
37198 PyObject * obj0 = 0 ;
37199 char *kwnames[] = {
37200 (char *) "self", NULL
37201 };
37202
37203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37205 if (SWIG_arg_fail(1)) SWIG_fail;
37206 {
37207 PyThreadState* __tstate = wxPyBeginAllowThreads();
37208 result = (arg1)->GetSize();
37209
37210 wxPyEndAllowThreads(__tstate);
37211 if (PyErr_Occurred()) SWIG_fail;
37212 }
37213 {
37214 wxSize * resultptr;
37215 resultptr = new wxSize((wxSize &)(result));
37216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37217 }
37218 return resultobj;
37219 fail:
37220 return NULL;
37221 }
37222
37223
37224 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37225 PyObject *resultobj;
37226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37227 wxSize result;
37228 PyObject * obj0 = 0 ;
37229 char *kwnames[] = {
37230 (char *) "self", NULL
37231 };
37232
37233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37235 if (SWIG_arg_fail(1)) SWIG_fail;
37236 {
37237 PyThreadState* __tstate = wxPyBeginAllowThreads();
37238 result = (arg1)->CalcMin();
37239
37240 wxPyEndAllowThreads(__tstate);
37241 if (PyErr_Occurred()) SWIG_fail;
37242 }
37243 {
37244 wxSize * resultptr;
37245 resultptr = new wxSize((wxSize &)(result));
37246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37247 }
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj;
37256 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37257 wxPoint arg2 ;
37258 wxSize arg3 ;
37259 PyObject * obj0 = 0 ;
37260 PyObject * obj1 = 0 ;
37261 PyObject * obj2 = 0 ;
37262 char *kwnames[] = {
37263 (char *) "self",(char *) "pos",(char *) "size", NULL
37264 };
37265
37266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37268 if (SWIG_arg_fail(1)) SWIG_fail;
37269 {
37270 wxPoint * argp;
37271 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37272 if (SWIG_arg_fail(2)) SWIG_fail;
37273 if (argp == NULL) {
37274 SWIG_null_ref("wxPoint");
37275 }
37276 if (SWIG_arg_fail(2)) SWIG_fail;
37277 arg2 = *argp;
37278 }
37279 {
37280 wxSize * argp;
37281 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37282 if (SWIG_arg_fail(3)) SWIG_fail;
37283 if (argp == NULL) {
37284 SWIG_null_ref("wxSize");
37285 }
37286 if (SWIG_arg_fail(3)) SWIG_fail;
37287 arg3 = *argp;
37288 }
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 (arg1)->SetDimension(arg2,arg3);
37292
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 Py_INCREF(Py_None); resultobj = Py_None;
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37304 PyObject *resultobj;
37305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37306 wxSize result;
37307 PyObject * obj0 = 0 ;
37308 char *kwnames[] = {
37309 (char *) "self", NULL
37310 };
37311
37312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37314 if (SWIG_arg_fail(1)) SWIG_fail;
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 result = (arg1)->GetMinSize();
37318
37319 wxPyEndAllowThreads(__tstate);
37320 if (PyErr_Occurred()) SWIG_fail;
37321 }
37322 {
37323 wxSize * resultptr;
37324 resultptr = new wxSize((wxSize &)(result));
37325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37326 }
37327 return resultobj;
37328 fail:
37329 return NULL;
37330 }
37331
37332
37333 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37334 PyObject *resultobj;
37335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37336 wxSize result;
37337 PyObject * obj0 = 0 ;
37338 char *kwnames[] = {
37339 (char *) "self", NULL
37340 };
37341
37342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37344 if (SWIG_arg_fail(1)) SWIG_fail;
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37348
37349 wxPyEndAllowThreads(__tstate);
37350 if (PyErr_Occurred()) SWIG_fail;
37351 }
37352 {
37353 wxSize * resultptr;
37354 resultptr = new wxSize((wxSize &)(result));
37355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37356 }
37357 return resultobj;
37358 fail:
37359 return NULL;
37360 }
37361
37362
37363 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37364 PyObject *resultobj;
37365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37366 int arg2 ;
37367 int arg3 ;
37368 PyObject * obj0 = 0 ;
37369 PyObject * obj1 = 0 ;
37370 PyObject * obj2 = 0 ;
37371 char *kwnames[] = {
37372 (char *) "self",(char *) "x",(char *) "y", NULL
37373 };
37374
37375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37377 if (SWIG_arg_fail(1)) SWIG_fail;
37378 {
37379 arg2 = (int)(SWIG_As_int(obj1));
37380 if (SWIG_arg_fail(2)) SWIG_fail;
37381 }
37382 {
37383 arg3 = (int)(SWIG_As_int(obj2));
37384 if (SWIG_arg_fail(3)) SWIG_fail;
37385 }
37386 {
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 (arg1)->SetInitSize(arg2,arg3);
37389
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 Py_INCREF(Py_None); resultobj = Py_None;
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj;
37402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37403 int arg2 ;
37404 int arg3 ;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 PyObject * obj2 = 0 ;
37408 char *kwnames[] = {
37409 (char *) "self",(char *) "width",(char *) "height", NULL
37410 };
37411
37412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37414 if (SWIG_arg_fail(1)) SWIG_fail;
37415 {
37416 arg2 = (int)(SWIG_As_int(obj1));
37417 if (SWIG_arg_fail(2)) SWIG_fail;
37418 }
37419 {
37420 arg3 = (int)(SWIG_As_int(obj2));
37421 if (SWIG_arg_fail(3)) SWIG_fail;
37422 }
37423 {
37424 PyThreadState* __tstate = wxPyBeginAllowThreads();
37425 (arg1)->SetRatio(arg2,arg3);
37426
37427 wxPyEndAllowThreads(__tstate);
37428 if (PyErr_Occurred()) SWIG_fail;
37429 }
37430 Py_INCREF(Py_None); resultobj = Py_None;
37431 return resultobj;
37432 fail:
37433 return NULL;
37434 }
37435
37436
37437 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37438 PyObject *resultobj;
37439 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37440 wxSize arg2 ;
37441 PyObject * obj0 = 0 ;
37442 PyObject * obj1 = 0 ;
37443 char *kwnames[] = {
37444 (char *) "self",(char *) "size", NULL
37445 };
37446
37447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37449 if (SWIG_arg_fail(1)) SWIG_fail;
37450 {
37451 wxSize * argp;
37452 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37453 if (SWIG_arg_fail(2)) SWIG_fail;
37454 if (argp == NULL) {
37455 SWIG_null_ref("wxSize");
37456 }
37457 if (SWIG_arg_fail(2)) SWIG_fail;
37458 arg2 = *argp;
37459 }
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 (arg1)->SetRatio(arg2);
37463
37464 wxPyEndAllowThreads(__tstate);
37465 if (PyErr_Occurred()) SWIG_fail;
37466 }
37467 Py_INCREF(Py_None); resultobj = Py_None;
37468 return resultobj;
37469 fail:
37470 return NULL;
37471 }
37472
37473
37474 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37475 PyObject *resultobj;
37476 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37477 float arg2 ;
37478 PyObject * obj0 = 0 ;
37479 PyObject * obj1 = 0 ;
37480 char *kwnames[] = {
37481 (char *) "self",(char *) "ratio", NULL
37482 };
37483
37484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37486 if (SWIG_arg_fail(1)) SWIG_fail;
37487 {
37488 arg2 = (float)(SWIG_As_float(obj1));
37489 if (SWIG_arg_fail(2)) SWIG_fail;
37490 }
37491 {
37492 PyThreadState* __tstate = wxPyBeginAllowThreads();
37493 (arg1)->SetRatio(arg2);
37494
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 Py_INCREF(Py_None); resultobj = Py_None;
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37506 PyObject *resultobj;
37507 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37508 float result;
37509 PyObject * obj0 = 0 ;
37510 char *kwnames[] = {
37511 (char *) "self", NULL
37512 };
37513
37514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37516 if (SWIG_arg_fail(1)) SWIG_fail;
37517 {
37518 PyThreadState* __tstate = wxPyBeginAllowThreads();
37519 result = (float)(arg1)->GetRatio();
37520
37521 wxPyEndAllowThreads(__tstate);
37522 if (PyErr_Occurred()) SWIG_fail;
37523 }
37524 {
37525 resultobj = SWIG_From_float((float)(result));
37526 }
37527 return resultobj;
37528 fail:
37529 return NULL;
37530 }
37531
37532
37533 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37534 PyObject *resultobj;
37535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37536 wxRect result;
37537 PyObject * obj0 = 0 ;
37538 char *kwnames[] = {
37539 (char *) "self", NULL
37540 };
37541
37542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37544 if (SWIG_arg_fail(1)) SWIG_fail;
37545 {
37546 PyThreadState* __tstate = wxPyBeginAllowThreads();
37547 result = (arg1)->GetRect();
37548
37549 wxPyEndAllowThreads(__tstate);
37550 if (PyErr_Occurred()) SWIG_fail;
37551 }
37552 {
37553 wxRect * resultptr;
37554 resultptr = new wxRect((wxRect &)(result));
37555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37556 }
37557 return resultobj;
37558 fail:
37559 return NULL;
37560 }
37561
37562
37563 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37564 PyObject *resultobj;
37565 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37566 bool result;
37567 PyObject * obj0 = 0 ;
37568 char *kwnames[] = {
37569 (char *) "self", NULL
37570 };
37571
37572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37574 if (SWIG_arg_fail(1)) SWIG_fail;
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 result = (bool)(arg1)->IsWindow();
37578
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37584 }
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37592 PyObject *resultobj;
37593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37594 bool result;
37595 PyObject * obj0 = 0 ;
37596 char *kwnames[] = {
37597 (char *) "self", NULL
37598 };
37599
37600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37602 if (SWIG_arg_fail(1)) SWIG_fail;
37603 {
37604 PyThreadState* __tstate = wxPyBeginAllowThreads();
37605 result = (bool)(arg1)->IsSizer();
37606
37607 wxPyEndAllowThreads(__tstate);
37608 if (PyErr_Occurred()) SWIG_fail;
37609 }
37610 {
37611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37612 }
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj;
37621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37622 bool result;
37623 PyObject * obj0 = 0 ;
37624 char *kwnames[] = {
37625 (char *) "self", NULL
37626 };
37627
37628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37630 if (SWIG_arg_fail(1)) SWIG_fail;
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 result = (bool)(arg1)->IsSpacer();
37634
37635 wxPyEndAllowThreads(__tstate);
37636 if (PyErr_Occurred()) SWIG_fail;
37637 }
37638 {
37639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37640 }
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37648 PyObject *resultobj;
37649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37650 int arg2 ;
37651 PyObject * obj0 = 0 ;
37652 PyObject * obj1 = 0 ;
37653 char *kwnames[] = {
37654 (char *) "self",(char *) "proportion", NULL
37655 };
37656
37657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37659 if (SWIG_arg_fail(1)) SWIG_fail;
37660 {
37661 arg2 = (int)(SWIG_As_int(obj1));
37662 if (SWIG_arg_fail(2)) SWIG_fail;
37663 }
37664 {
37665 PyThreadState* __tstate = wxPyBeginAllowThreads();
37666 (arg1)->SetProportion(arg2);
37667
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 Py_INCREF(Py_None); resultobj = Py_None;
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37681 int result;
37682 PyObject * obj0 = 0 ;
37683 char *kwnames[] = {
37684 (char *) "self", NULL
37685 };
37686
37687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37689 if (SWIG_arg_fail(1)) SWIG_fail;
37690 {
37691 PyThreadState* __tstate = wxPyBeginAllowThreads();
37692 result = (int)(arg1)->GetProportion();
37693
37694 wxPyEndAllowThreads(__tstate);
37695 if (PyErr_Occurred()) SWIG_fail;
37696 }
37697 {
37698 resultobj = SWIG_From_int((int)(result));
37699 }
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj;
37708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37709 int arg2 ;
37710 PyObject * obj0 = 0 ;
37711 PyObject * obj1 = 0 ;
37712 char *kwnames[] = {
37713 (char *) "self",(char *) "flag", NULL
37714 };
37715
37716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37718 if (SWIG_arg_fail(1)) SWIG_fail;
37719 {
37720 arg2 = (int)(SWIG_As_int(obj1));
37721 if (SWIG_arg_fail(2)) SWIG_fail;
37722 }
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 (arg1)->SetFlag(arg2);
37726
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 Py_INCREF(Py_None); resultobj = Py_None;
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj;
37739 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37740 int result;
37741 PyObject * obj0 = 0 ;
37742 char *kwnames[] = {
37743 (char *) "self", NULL
37744 };
37745
37746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37748 if (SWIG_arg_fail(1)) SWIG_fail;
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 result = (int)(arg1)->GetFlag();
37752
37753 wxPyEndAllowThreads(__tstate);
37754 if (PyErr_Occurred()) SWIG_fail;
37755 }
37756 {
37757 resultobj = SWIG_From_int((int)(result));
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37768 int arg2 ;
37769 PyObject * obj0 = 0 ;
37770 PyObject * obj1 = 0 ;
37771 char *kwnames[] = {
37772 (char *) "self",(char *) "border", NULL
37773 };
37774
37775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37777 if (SWIG_arg_fail(1)) SWIG_fail;
37778 {
37779 arg2 = (int)(SWIG_As_int(obj1));
37780 if (SWIG_arg_fail(2)) SWIG_fail;
37781 }
37782 {
37783 PyThreadState* __tstate = wxPyBeginAllowThreads();
37784 (arg1)->SetBorder(arg2);
37785
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 Py_INCREF(Py_None); resultobj = Py_None;
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37797 PyObject *resultobj;
37798 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37799 int result;
37800 PyObject * obj0 = 0 ;
37801 char *kwnames[] = {
37802 (char *) "self", NULL
37803 };
37804
37805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 result = (int)(arg1)->GetBorder();
37811
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 {
37816 resultobj = SWIG_From_int((int)(result));
37817 }
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37825 PyObject *resultobj;
37826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37827 wxWindow *result;
37828 PyObject * obj0 = 0 ;
37829 char *kwnames[] = {
37830 (char *) "self", NULL
37831 };
37832
37833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
37834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37835 if (SWIG_arg_fail(1)) SWIG_fail;
37836 {
37837 PyThreadState* __tstate = wxPyBeginAllowThreads();
37838 result = (wxWindow *)(arg1)->GetWindow();
37839
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = wxPyMake_wxObject(result, 0);
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj;
37854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37855 wxWindow *arg2 = (wxWindow *) 0 ;
37856 PyObject * obj0 = 0 ;
37857 PyObject * obj1 = 0 ;
37858 char *kwnames[] = {
37859 (char *) "self",(char *) "window", NULL
37860 };
37861
37862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37864 if (SWIG_arg_fail(1)) SWIG_fail;
37865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37866 if (SWIG_arg_fail(2)) SWIG_fail;
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 (arg1)->SetWindow(arg2);
37870
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 Py_INCREF(Py_None); resultobj = Py_None;
37875 return resultobj;
37876 fail:
37877 return NULL;
37878 }
37879
37880
37881 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37882 PyObject *resultobj;
37883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37884 wxSizer *result;
37885 PyObject * obj0 = 0 ;
37886 char *kwnames[] = {
37887 (char *) "self", NULL
37888 };
37889
37890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
37891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37892 if (SWIG_arg_fail(1)) SWIG_fail;
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 result = (wxSizer *)(arg1)->GetSizer();
37896
37897 wxPyEndAllowThreads(__tstate);
37898 if (PyErr_Occurred()) SWIG_fail;
37899 }
37900 {
37901 resultobj = wxPyMake_wxSizer(result, 0);
37902 }
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37910 PyObject *resultobj;
37911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37912 wxSizer *arg2 = (wxSizer *) 0 ;
37913 PyObject * obj0 = 0 ;
37914 PyObject * obj1 = 0 ;
37915 char *kwnames[] = {
37916 (char *) "self",(char *) "sizer", NULL
37917 };
37918
37919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
37920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37921 if (SWIG_arg_fail(1)) SWIG_fail;
37922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37923 if (SWIG_arg_fail(2)) SWIG_fail;
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 (arg1)->SetSizer(arg2);
37927
37928 wxPyEndAllowThreads(__tstate);
37929 if (PyErr_Occurred()) SWIG_fail;
37930 }
37931 Py_INCREF(Py_None); resultobj = Py_None;
37932 return resultobj;
37933 fail:
37934 return NULL;
37935 }
37936
37937
37938 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37939 PyObject *resultobj;
37940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37941 wxSize *result;
37942 PyObject * obj0 = 0 ;
37943 char *kwnames[] = {
37944 (char *) "self", NULL
37945 };
37946
37947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
37948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37949 if (SWIG_arg_fail(1)) SWIG_fail;
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 {
37953 wxSize const &_result_ref = (arg1)->GetSpacer();
37954 result = (wxSize *) &_result_ref;
37955 }
37956
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj;
37969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37970 wxSize *arg2 = 0 ;
37971 wxSize temp2 ;
37972 PyObject * obj0 = 0 ;
37973 PyObject * obj1 = 0 ;
37974 char *kwnames[] = {
37975 (char *) "self",(char *) "size", NULL
37976 };
37977
37978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
37979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37980 if (SWIG_arg_fail(1)) SWIG_fail;
37981 {
37982 arg2 = &temp2;
37983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37984 }
37985 {
37986 PyThreadState* __tstate = wxPyBeginAllowThreads();
37987 (arg1)->SetSpacer((wxSize const &)*arg2);
37988
37989 wxPyEndAllowThreads(__tstate);
37990 if (PyErr_Occurred()) SWIG_fail;
37991 }
37992 Py_INCREF(Py_None); resultobj = Py_None;
37993 return resultobj;
37994 fail:
37995 return NULL;
37996 }
37997
37998
37999 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38000 PyObject *resultobj;
38001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38002 bool arg2 ;
38003 PyObject * obj0 = 0 ;
38004 PyObject * obj1 = 0 ;
38005 char *kwnames[] = {
38006 (char *) "self",(char *) "show", NULL
38007 };
38008
38009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38011 if (SWIG_arg_fail(1)) SWIG_fail;
38012 {
38013 arg2 = (bool)(SWIG_As_bool(obj1));
38014 if (SWIG_arg_fail(2)) SWIG_fail;
38015 }
38016 {
38017 PyThreadState* __tstate = wxPyBeginAllowThreads();
38018 (arg1)->Show(arg2);
38019
38020 wxPyEndAllowThreads(__tstate);
38021 if (PyErr_Occurred()) SWIG_fail;
38022 }
38023 Py_INCREF(Py_None); resultobj = Py_None;
38024 return resultobj;
38025 fail:
38026 return NULL;
38027 }
38028
38029
38030 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38031 PyObject *resultobj;
38032 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38033 bool result;
38034 PyObject * obj0 = 0 ;
38035 char *kwnames[] = {
38036 (char *) "self", NULL
38037 };
38038
38039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38041 if (SWIG_arg_fail(1)) SWIG_fail;
38042 {
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 result = (bool)(arg1)->IsShown();
38045
38046 wxPyEndAllowThreads(__tstate);
38047 if (PyErr_Occurred()) SWIG_fail;
38048 }
38049 {
38050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38051 }
38052 return resultobj;
38053 fail:
38054 return NULL;
38055 }
38056
38057
38058 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38059 PyObject *resultobj;
38060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38061 wxPoint result;
38062 PyObject * obj0 = 0 ;
38063 char *kwnames[] = {
38064 (char *) "self", NULL
38065 };
38066
38067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38069 if (SWIG_arg_fail(1)) SWIG_fail;
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (arg1)->GetPosition();
38073
38074 wxPyEndAllowThreads(__tstate);
38075 if (PyErr_Occurred()) SWIG_fail;
38076 }
38077 {
38078 wxPoint * resultptr;
38079 resultptr = new wxPoint((wxPoint &)(result));
38080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38081 }
38082 return resultobj;
38083 fail:
38084 return NULL;
38085 }
38086
38087
38088 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38089 PyObject *resultobj;
38090 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38091 PyObject *result;
38092 PyObject * obj0 = 0 ;
38093 char *kwnames[] = {
38094 (char *) "self", NULL
38095 };
38096
38097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38099 if (SWIG_arg_fail(1)) SWIG_fail;
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38103
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = result;
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38115 PyObject *obj;
38116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38117 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38118 Py_INCREF(obj);
38119 return Py_BuildValue((char *)"");
38120 }
38121 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38122 PyObject *resultobj;
38123 wxSizer *arg1 = (wxSizer *) 0 ;
38124 PyObject *arg2 = (PyObject *) 0 ;
38125 PyObject * obj0 = 0 ;
38126 PyObject * obj1 = 0 ;
38127 char *kwnames[] = {
38128 (char *) "self",(char *) "_self", NULL
38129 };
38130
38131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38133 if (SWIG_arg_fail(1)) SWIG_fail;
38134 arg2 = obj1;
38135 {
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 wxSizer__setOORInfo(arg1,arg2);
38138
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 Py_INCREF(Py_None); resultobj = Py_None;
38143 return resultobj;
38144 fail:
38145 return NULL;
38146 }
38147
38148
38149 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj;
38151 wxSizer *arg1 = (wxSizer *) 0 ;
38152 PyObject *arg2 = (PyObject *) 0 ;
38153 int arg3 = (int) 0 ;
38154 int arg4 = (int) 0 ;
38155 int arg5 = (int) 0 ;
38156 PyObject *arg6 = (PyObject *) NULL ;
38157 wxSizerItem *result;
38158 PyObject * obj0 = 0 ;
38159 PyObject * obj1 = 0 ;
38160 PyObject * obj2 = 0 ;
38161 PyObject * obj3 = 0 ;
38162 PyObject * obj4 = 0 ;
38163 PyObject * obj5 = 0 ;
38164 char *kwnames[] = {
38165 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38166 };
38167
38168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38170 if (SWIG_arg_fail(1)) SWIG_fail;
38171 arg2 = obj1;
38172 if (obj2) {
38173 {
38174 arg3 = (int)(SWIG_As_int(obj2));
38175 if (SWIG_arg_fail(3)) SWIG_fail;
38176 }
38177 }
38178 if (obj3) {
38179 {
38180 arg4 = (int)(SWIG_As_int(obj3));
38181 if (SWIG_arg_fail(4)) SWIG_fail;
38182 }
38183 }
38184 if (obj4) {
38185 {
38186 arg5 = (int)(SWIG_As_int(obj4));
38187 if (SWIG_arg_fail(5)) SWIG_fail;
38188 }
38189 }
38190 if (obj5) {
38191 arg6 = obj5;
38192 }
38193 {
38194 PyThreadState* __tstate = wxPyBeginAllowThreads();
38195 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38196
38197 wxPyEndAllowThreads(__tstate);
38198 if (PyErr_Occurred()) SWIG_fail;
38199 }
38200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38201 return resultobj;
38202 fail:
38203 return NULL;
38204 }
38205
38206
38207 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj;
38209 wxSizer *arg1 = (wxSizer *) 0 ;
38210 int arg2 ;
38211 PyObject *arg3 = (PyObject *) 0 ;
38212 int arg4 = (int) 0 ;
38213 int arg5 = (int) 0 ;
38214 int arg6 = (int) 0 ;
38215 PyObject *arg7 = (PyObject *) NULL ;
38216 wxSizerItem *result;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 PyObject * obj2 = 0 ;
38220 PyObject * obj3 = 0 ;
38221 PyObject * obj4 = 0 ;
38222 PyObject * obj5 = 0 ;
38223 PyObject * obj6 = 0 ;
38224 char *kwnames[] = {
38225 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38226 };
38227
38228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38230 if (SWIG_arg_fail(1)) SWIG_fail;
38231 {
38232 arg2 = (int)(SWIG_As_int(obj1));
38233 if (SWIG_arg_fail(2)) SWIG_fail;
38234 }
38235 arg3 = obj2;
38236 if (obj3) {
38237 {
38238 arg4 = (int)(SWIG_As_int(obj3));
38239 if (SWIG_arg_fail(4)) SWIG_fail;
38240 }
38241 }
38242 if (obj4) {
38243 {
38244 arg5 = (int)(SWIG_As_int(obj4));
38245 if (SWIG_arg_fail(5)) SWIG_fail;
38246 }
38247 }
38248 if (obj5) {
38249 {
38250 arg6 = (int)(SWIG_As_int(obj5));
38251 if (SWIG_arg_fail(6)) SWIG_fail;
38252 }
38253 }
38254 if (obj6) {
38255 arg7 = obj6;
38256 }
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38260
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38272 PyObject *resultobj;
38273 wxSizer *arg1 = (wxSizer *) 0 ;
38274 PyObject *arg2 = (PyObject *) 0 ;
38275 int arg3 = (int) 0 ;
38276 int arg4 = (int) 0 ;
38277 int arg5 = (int) 0 ;
38278 PyObject *arg6 = (PyObject *) NULL ;
38279 wxSizerItem *result;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 PyObject * obj2 = 0 ;
38283 PyObject * obj3 = 0 ;
38284 PyObject * obj4 = 0 ;
38285 PyObject * obj5 = 0 ;
38286 char *kwnames[] = {
38287 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38288 };
38289
38290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38292 if (SWIG_arg_fail(1)) SWIG_fail;
38293 arg2 = obj1;
38294 if (obj2) {
38295 {
38296 arg3 = (int)(SWIG_As_int(obj2));
38297 if (SWIG_arg_fail(3)) SWIG_fail;
38298 }
38299 }
38300 if (obj3) {
38301 {
38302 arg4 = (int)(SWIG_As_int(obj3));
38303 if (SWIG_arg_fail(4)) SWIG_fail;
38304 }
38305 }
38306 if (obj4) {
38307 {
38308 arg5 = (int)(SWIG_As_int(obj4));
38309 if (SWIG_arg_fail(5)) SWIG_fail;
38310 }
38311 }
38312 if (obj5) {
38313 arg6 = obj5;
38314 }
38315 {
38316 PyThreadState* __tstate = wxPyBeginAllowThreads();
38317 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38318
38319 wxPyEndAllowThreads(__tstate);
38320 if (PyErr_Occurred()) SWIG_fail;
38321 }
38322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj;
38331 wxSizer *arg1 = (wxSizer *) 0 ;
38332 PyObject *arg2 = (PyObject *) 0 ;
38333 bool result;
38334 PyObject * obj0 = 0 ;
38335 PyObject * obj1 = 0 ;
38336 char *kwnames[] = {
38337 (char *) "self",(char *) "item", NULL
38338 };
38339
38340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38342 if (SWIG_arg_fail(1)) SWIG_fail;
38343 arg2 = obj1;
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (bool)wxSizer_Remove(arg1,arg2);
38347
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 {
38352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38353 }
38354 return resultobj;
38355 fail:
38356 return NULL;
38357 }
38358
38359
38360 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38361 PyObject *resultobj;
38362 wxSizer *arg1 = (wxSizer *) 0 ;
38363 PyObject *arg2 = (PyObject *) 0 ;
38364 bool result;
38365 PyObject * obj0 = 0 ;
38366 PyObject * obj1 = 0 ;
38367 char *kwnames[] = {
38368 (char *) "self",(char *) "item", NULL
38369 };
38370
38371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38373 if (SWIG_arg_fail(1)) SWIG_fail;
38374 arg2 = obj1;
38375 {
38376 PyThreadState* __tstate = wxPyBeginAllowThreads();
38377 result = (bool)wxSizer_Detach(arg1,arg2);
38378
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 {
38383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38384 }
38385 return resultobj;
38386 fail:
38387 return NULL;
38388 }
38389
38390
38391 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38392 PyObject *resultobj;
38393 wxSizer *arg1 = (wxSizer *) 0 ;
38394 PyObject *arg2 = (PyObject *) 0 ;
38395 wxSizerItem *result;
38396 PyObject * obj0 = 0 ;
38397 PyObject * obj1 = 0 ;
38398 char *kwnames[] = {
38399 (char *) "self",(char *) "item", NULL
38400 };
38401
38402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38404 if (SWIG_arg_fail(1)) SWIG_fail;
38405 arg2 = obj1;
38406 {
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38409
38410 wxPyEndAllowThreads(__tstate);
38411 if (PyErr_Occurred()) SWIG_fail;
38412 }
38413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38414 return resultobj;
38415 fail:
38416 return NULL;
38417 }
38418
38419
38420 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38421 PyObject *resultobj;
38422 wxSizer *arg1 = (wxSizer *) 0 ;
38423 PyObject *arg2 = (PyObject *) 0 ;
38424 wxSize *arg3 = 0 ;
38425 wxSize temp3 ;
38426 PyObject * obj0 = 0 ;
38427 PyObject * obj1 = 0 ;
38428 PyObject * obj2 = 0 ;
38429 char *kwnames[] = {
38430 (char *) "self",(char *) "item",(char *) "size", NULL
38431 };
38432
38433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38435 if (SWIG_arg_fail(1)) SWIG_fail;
38436 arg2 = obj1;
38437 {
38438 arg3 = &temp3;
38439 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38440 }
38441 {
38442 PyThreadState* __tstate = wxPyBeginAllowThreads();
38443 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38444
38445 wxPyEndAllowThreads(__tstate);
38446 if (PyErr_Occurred()) SWIG_fail;
38447 }
38448 Py_INCREF(Py_None); resultobj = Py_None;
38449 return resultobj;
38450 fail:
38451 return NULL;
38452 }
38453
38454
38455 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38456 PyObject *resultobj;
38457 wxSizer *arg1 = (wxSizer *) 0 ;
38458 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38459 wxSizerItem *result;
38460 PyObject * obj0 = 0 ;
38461 PyObject * obj1 = 0 ;
38462 char *kwnames[] = {
38463 (char *) "self",(char *) "item", NULL
38464 };
38465
38466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38468 if (SWIG_arg_fail(1)) SWIG_fail;
38469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38470 if (SWIG_arg_fail(2)) SWIG_fail;
38471 {
38472 PyThreadState* __tstate = wxPyBeginAllowThreads();
38473 result = (wxSizerItem *)(arg1)->Add(arg2);
38474
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38479 return resultobj;
38480 fail:
38481 return NULL;
38482 }
38483
38484
38485 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38486 PyObject *resultobj;
38487 wxSizer *arg1 = (wxSizer *) 0 ;
38488 size_t arg2 ;
38489 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38490 wxSizerItem *result;
38491 PyObject * obj0 = 0 ;
38492 PyObject * obj1 = 0 ;
38493 PyObject * obj2 = 0 ;
38494 char *kwnames[] = {
38495 (char *) "self",(char *) "index",(char *) "item", NULL
38496 };
38497
38498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38500 if (SWIG_arg_fail(1)) SWIG_fail;
38501 {
38502 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38503 if (SWIG_arg_fail(2)) SWIG_fail;
38504 }
38505 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38506 if (SWIG_arg_fail(3)) SWIG_fail;
38507 {
38508 PyThreadState* __tstate = wxPyBeginAllowThreads();
38509 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38510
38511 wxPyEndAllowThreads(__tstate);
38512 if (PyErr_Occurred()) SWIG_fail;
38513 }
38514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38515 return resultobj;
38516 fail:
38517 return NULL;
38518 }
38519
38520
38521 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38522 PyObject *resultobj;
38523 wxSizer *arg1 = (wxSizer *) 0 ;
38524 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38525 wxSizerItem *result;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 char *kwnames[] = {
38529 (char *) "self",(char *) "item", NULL
38530 };
38531
38532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38534 if (SWIG_arg_fail(1)) SWIG_fail;
38535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38536 if (SWIG_arg_fail(2)) SWIG_fail;
38537 {
38538 PyThreadState* __tstate = wxPyBeginAllowThreads();
38539 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38540
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38545 return resultobj;
38546 fail:
38547 return NULL;
38548 }
38549
38550
38551 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj;
38553 wxSizer *arg1 = (wxSizer *) 0 ;
38554 int arg2 ;
38555 int arg3 ;
38556 int arg4 ;
38557 int arg5 ;
38558 PyObject * obj0 = 0 ;
38559 PyObject * obj1 = 0 ;
38560 PyObject * obj2 = 0 ;
38561 PyObject * obj3 = 0 ;
38562 PyObject * obj4 = 0 ;
38563 char *kwnames[] = {
38564 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38565 };
38566
38567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38569 if (SWIG_arg_fail(1)) SWIG_fail;
38570 {
38571 arg2 = (int)(SWIG_As_int(obj1));
38572 if (SWIG_arg_fail(2)) SWIG_fail;
38573 }
38574 {
38575 arg3 = (int)(SWIG_As_int(obj2));
38576 if (SWIG_arg_fail(3)) SWIG_fail;
38577 }
38578 {
38579 arg4 = (int)(SWIG_As_int(obj3));
38580 if (SWIG_arg_fail(4)) SWIG_fail;
38581 }
38582 {
38583 arg5 = (int)(SWIG_As_int(obj4));
38584 if (SWIG_arg_fail(5)) SWIG_fail;
38585 }
38586 {
38587 PyThreadState* __tstate = wxPyBeginAllowThreads();
38588 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38589
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 Py_INCREF(Py_None); resultobj = Py_None;
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38601 PyObject *resultobj;
38602 wxSizer *arg1 = (wxSizer *) 0 ;
38603 wxSize *arg2 = 0 ;
38604 wxSize temp2 ;
38605 PyObject * obj0 = 0 ;
38606 PyObject * obj1 = 0 ;
38607 char *kwnames[] = {
38608 (char *) "self",(char *) "size", NULL
38609 };
38610
38611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38613 if (SWIG_arg_fail(1)) SWIG_fail;
38614 {
38615 arg2 = &temp2;
38616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38617 }
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 (arg1)->SetMinSize((wxSize const &)*arg2);
38621
38622 wxPyEndAllowThreads(__tstate);
38623 if (PyErr_Occurred()) SWIG_fail;
38624 }
38625 Py_INCREF(Py_None); resultobj = Py_None;
38626 return resultobj;
38627 fail:
38628 return NULL;
38629 }
38630
38631
38632 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38633 PyObject *resultobj;
38634 wxSizer *arg1 = (wxSizer *) 0 ;
38635 wxSize result;
38636 PyObject * obj0 = 0 ;
38637 char *kwnames[] = {
38638 (char *) "self", NULL
38639 };
38640
38641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38643 if (SWIG_arg_fail(1)) SWIG_fail;
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (arg1)->GetSize();
38647
38648 wxPyEndAllowThreads(__tstate);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 }
38651 {
38652 wxSize * resultptr;
38653 resultptr = new wxSize((wxSize &)(result));
38654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38655 }
38656 return resultobj;
38657 fail:
38658 return NULL;
38659 }
38660
38661
38662 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38663 PyObject *resultobj;
38664 wxSizer *arg1 = (wxSizer *) 0 ;
38665 wxPoint result;
38666 PyObject * obj0 = 0 ;
38667 char *kwnames[] = {
38668 (char *) "self", NULL
38669 };
38670
38671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38673 if (SWIG_arg_fail(1)) SWIG_fail;
38674 {
38675 PyThreadState* __tstate = wxPyBeginAllowThreads();
38676 result = (arg1)->GetPosition();
38677
38678 wxPyEndAllowThreads(__tstate);
38679 if (PyErr_Occurred()) SWIG_fail;
38680 }
38681 {
38682 wxPoint * resultptr;
38683 resultptr = new wxPoint((wxPoint &)(result));
38684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38685 }
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38693 PyObject *resultobj;
38694 wxSizer *arg1 = (wxSizer *) 0 ;
38695 wxSize result;
38696 PyObject * obj0 = 0 ;
38697 char *kwnames[] = {
38698 (char *) "self", NULL
38699 };
38700
38701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38703 if (SWIG_arg_fail(1)) SWIG_fail;
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 result = (arg1)->GetMinSize();
38707
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 {
38712 wxSize * resultptr;
38713 resultptr = new wxSize((wxSize &)(result));
38714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38715 }
38716 return resultobj;
38717 fail:
38718 return NULL;
38719 }
38720
38721
38722 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38723 PyObject *resultobj;
38724 wxSizer *arg1 = (wxSizer *) 0 ;
38725 PyObject * obj0 = 0 ;
38726 char *kwnames[] = {
38727 (char *) "self", NULL
38728 };
38729
38730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38732 if (SWIG_arg_fail(1)) SWIG_fail;
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 (arg1)->RecalcSizes();
38736
38737 wxPyEndAllowThreads(__tstate);
38738 if (PyErr_Occurred()) SWIG_fail;
38739 }
38740 Py_INCREF(Py_None); resultobj = Py_None;
38741 return resultobj;
38742 fail:
38743 return NULL;
38744 }
38745
38746
38747 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38748 PyObject *resultobj;
38749 wxSizer *arg1 = (wxSizer *) 0 ;
38750 wxSize result;
38751 PyObject * obj0 = 0 ;
38752 char *kwnames[] = {
38753 (char *) "self", NULL
38754 };
38755
38756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38758 if (SWIG_arg_fail(1)) SWIG_fail;
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 result = (arg1)->CalcMin();
38762
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 {
38767 wxSize * resultptr;
38768 resultptr = new wxSize((wxSize &)(result));
38769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38770 }
38771 return resultobj;
38772 fail:
38773 return NULL;
38774 }
38775
38776
38777 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38778 PyObject *resultobj;
38779 wxSizer *arg1 = (wxSizer *) 0 ;
38780 PyObject * obj0 = 0 ;
38781 char *kwnames[] = {
38782 (char *) "self", NULL
38783 };
38784
38785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38787 if (SWIG_arg_fail(1)) SWIG_fail;
38788 {
38789 PyThreadState* __tstate = wxPyBeginAllowThreads();
38790 (arg1)->Layout();
38791
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 Py_INCREF(Py_None); resultobj = Py_None;
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38803 PyObject *resultobj;
38804 wxSizer *arg1 = (wxSizer *) 0 ;
38805 wxWindow *arg2 = (wxWindow *) 0 ;
38806 wxSize result;
38807 PyObject * obj0 = 0 ;
38808 PyObject * obj1 = 0 ;
38809 char *kwnames[] = {
38810 (char *) "self",(char *) "window", NULL
38811 };
38812
38813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38815 if (SWIG_arg_fail(1)) SWIG_fail;
38816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38817 if (SWIG_arg_fail(2)) SWIG_fail;
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 result = (arg1)->Fit(arg2);
38821
38822 wxPyEndAllowThreads(__tstate);
38823 if (PyErr_Occurred()) SWIG_fail;
38824 }
38825 {
38826 wxSize * resultptr;
38827 resultptr = new wxSize((wxSize &)(result));
38828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38829 }
38830 return resultobj;
38831 fail:
38832 return NULL;
38833 }
38834
38835
38836 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38837 PyObject *resultobj;
38838 wxSizer *arg1 = (wxSizer *) 0 ;
38839 wxWindow *arg2 = (wxWindow *) 0 ;
38840 PyObject * obj0 = 0 ;
38841 PyObject * obj1 = 0 ;
38842 char *kwnames[] = {
38843 (char *) "self",(char *) "window", NULL
38844 };
38845
38846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38848 if (SWIG_arg_fail(1)) SWIG_fail;
38849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38850 if (SWIG_arg_fail(2)) SWIG_fail;
38851 {
38852 PyThreadState* __tstate = wxPyBeginAllowThreads();
38853 (arg1)->FitInside(arg2);
38854
38855 wxPyEndAllowThreads(__tstate);
38856 if (PyErr_Occurred()) SWIG_fail;
38857 }
38858 Py_INCREF(Py_None); resultobj = Py_None;
38859 return resultobj;
38860 fail:
38861 return NULL;
38862 }
38863
38864
38865 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38866 PyObject *resultobj;
38867 wxSizer *arg1 = (wxSizer *) 0 ;
38868 wxWindow *arg2 = (wxWindow *) 0 ;
38869 PyObject * obj0 = 0 ;
38870 PyObject * obj1 = 0 ;
38871 char *kwnames[] = {
38872 (char *) "self",(char *) "window", NULL
38873 };
38874
38875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
38876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38877 if (SWIG_arg_fail(1)) SWIG_fail;
38878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38879 if (SWIG_arg_fail(2)) SWIG_fail;
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 (arg1)->SetSizeHints(arg2);
38883
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 Py_INCREF(Py_None); resultobj = Py_None;
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj;
38896 wxSizer *arg1 = (wxSizer *) 0 ;
38897 wxWindow *arg2 = (wxWindow *) 0 ;
38898 PyObject * obj0 = 0 ;
38899 PyObject * obj1 = 0 ;
38900 char *kwnames[] = {
38901 (char *) "self",(char *) "window", NULL
38902 };
38903
38904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
38905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38906 if (SWIG_arg_fail(1)) SWIG_fail;
38907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38908 if (SWIG_arg_fail(2)) SWIG_fail;
38909 {
38910 PyThreadState* __tstate = wxPyBeginAllowThreads();
38911 (arg1)->SetVirtualSizeHints(arg2);
38912
38913 wxPyEndAllowThreads(__tstate);
38914 if (PyErr_Occurred()) SWIG_fail;
38915 }
38916 Py_INCREF(Py_None); resultobj = Py_None;
38917 return resultobj;
38918 fail:
38919 return NULL;
38920 }
38921
38922
38923 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38924 PyObject *resultobj;
38925 wxSizer *arg1 = (wxSizer *) 0 ;
38926 bool arg2 = (bool) false ;
38927 PyObject * obj0 = 0 ;
38928 PyObject * obj1 = 0 ;
38929 char *kwnames[] = {
38930 (char *) "self",(char *) "deleteWindows", NULL
38931 };
38932
38933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
38934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38935 if (SWIG_arg_fail(1)) SWIG_fail;
38936 if (obj1) {
38937 {
38938 arg2 = (bool)(SWIG_As_bool(obj1));
38939 if (SWIG_arg_fail(2)) SWIG_fail;
38940 }
38941 }
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 (arg1)->Clear(arg2);
38945
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 Py_INCREF(Py_None); resultobj = Py_None;
38950 return resultobj;
38951 fail:
38952 return NULL;
38953 }
38954
38955
38956 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38957 PyObject *resultobj;
38958 wxSizer *arg1 = (wxSizer *) 0 ;
38959 PyObject * obj0 = 0 ;
38960 char *kwnames[] = {
38961 (char *) "self", NULL
38962 };
38963
38964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
38965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38966 if (SWIG_arg_fail(1)) SWIG_fail;
38967 {
38968 PyThreadState* __tstate = wxPyBeginAllowThreads();
38969 (arg1)->DeleteWindows();
38970
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 Py_INCREF(Py_None); resultobj = Py_None;
38975 return resultobj;
38976 fail:
38977 return NULL;
38978 }
38979
38980
38981 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj;
38983 wxSizer *arg1 = (wxSizer *) 0 ;
38984 PyObject *result;
38985 PyObject * obj0 = 0 ;
38986 char *kwnames[] = {
38987 (char *) "self", NULL
38988 };
38989
38990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
38991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38992 if (SWIG_arg_fail(1)) SWIG_fail;
38993 {
38994 PyThreadState* __tstate = wxPyBeginAllowThreads();
38995 result = (PyObject *)wxSizer_GetChildren(arg1);
38996
38997 wxPyEndAllowThreads(__tstate);
38998 if (PyErr_Occurred()) SWIG_fail;
38999 }
39000 resultobj = result;
39001 return resultobj;
39002 fail:
39003 return NULL;
39004 }
39005
39006
39007 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39008 PyObject *resultobj;
39009 wxSizer *arg1 = (wxSizer *) 0 ;
39010 PyObject *arg2 = (PyObject *) 0 ;
39011 bool arg3 = (bool) true ;
39012 bool arg4 = (bool) false ;
39013 bool result;
39014 PyObject * obj0 = 0 ;
39015 PyObject * obj1 = 0 ;
39016 PyObject * obj2 = 0 ;
39017 PyObject * obj3 = 0 ;
39018 char *kwnames[] = {
39019 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39020 };
39021
39022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39024 if (SWIG_arg_fail(1)) SWIG_fail;
39025 arg2 = obj1;
39026 if (obj2) {
39027 {
39028 arg3 = (bool)(SWIG_As_bool(obj2));
39029 if (SWIG_arg_fail(3)) SWIG_fail;
39030 }
39031 }
39032 if (obj3) {
39033 {
39034 arg4 = (bool)(SWIG_As_bool(obj3));
39035 if (SWIG_arg_fail(4)) SWIG_fail;
39036 }
39037 }
39038 {
39039 PyThreadState* __tstate = wxPyBeginAllowThreads();
39040 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39041
39042 wxPyEndAllowThreads(__tstate);
39043 if (PyErr_Occurred()) SWIG_fail;
39044 }
39045 {
39046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39047 }
39048 return resultobj;
39049 fail:
39050 return NULL;
39051 }
39052
39053
39054 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39055 PyObject *resultobj;
39056 wxSizer *arg1 = (wxSizer *) 0 ;
39057 PyObject *arg2 = (PyObject *) 0 ;
39058 bool result;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 char *kwnames[] = {
39062 (char *) "self",(char *) "item", NULL
39063 };
39064
39065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39067 if (SWIG_arg_fail(1)) SWIG_fail;
39068 arg2 = obj1;
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 result = (bool)wxSizer_IsShown(arg1,arg2);
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39078 }
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj;
39087 wxSizer *arg1 = (wxSizer *) 0 ;
39088 bool arg2 ;
39089 PyObject * obj0 = 0 ;
39090 PyObject * obj1 = 0 ;
39091 char *kwnames[] = {
39092 (char *) "self",(char *) "show", NULL
39093 };
39094
39095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39097 if (SWIG_arg_fail(1)) SWIG_fail;
39098 {
39099 arg2 = (bool)(SWIG_As_bool(obj1));
39100 if (SWIG_arg_fail(2)) SWIG_fail;
39101 }
39102 {
39103 PyThreadState* __tstate = wxPyBeginAllowThreads();
39104 (arg1)->ShowItems(arg2);
39105
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 Py_INCREF(Py_None); resultobj = Py_None;
39110 return resultobj;
39111 fail:
39112 return NULL;
39113 }
39114
39115
39116 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39117 PyObject *obj;
39118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39119 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39120 Py_INCREF(obj);
39121 return Py_BuildValue((char *)"");
39122 }
39123 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39124 PyObject *resultobj;
39125 wxPySizer *result;
39126 char *kwnames[] = {
39127 NULL
39128 };
39129
39130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 result = (wxPySizer *)new wxPySizer();
39134
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39146 PyObject *resultobj;
39147 wxPySizer *arg1 = (wxPySizer *) 0 ;
39148 PyObject *arg2 = (PyObject *) 0 ;
39149 PyObject *arg3 = (PyObject *) 0 ;
39150 PyObject * obj0 = 0 ;
39151 PyObject * obj1 = 0 ;
39152 PyObject * obj2 = 0 ;
39153 char *kwnames[] = {
39154 (char *) "self",(char *) "self",(char *) "_class", NULL
39155 };
39156
39157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39159 if (SWIG_arg_fail(1)) SWIG_fail;
39160 arg2 = obj1;
39161 arg3 = obj2;
39162 {
39163 PyThreadState* __tstate = wxPyBeginAllowThreads();
39164 (arg1)->_setCallbackInfo(arg2,arg3);
39165
39166 wxPyEndAllowThreads(__tstate);
39167 if (PyErr_Occurred()) SWIG_fail;
39168 }
39169 Py_INCREF(Py_None); resultobj = Py_None;
39170 return resultobj;
39171 fail:
39172 return NULL;
39173 }
39174
39175
39176 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39177 PyObject *obj;
39178 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39179 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39180 Py_INCREF(obj);
39181 return Py_BuildValue((char *)"");
39182 }
39183 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39184 PyObject *resultobj;
39185 int arg1 = (int) wxHORIZONTAL ;
39186 wxBoxSizer *result;
39187 PyObject * obj0 = 0 ;
39188 char *kwnames[] = {
39189 (char *) "orient", NULL
39190 };
39191
39192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39193 if (obj0) {
39194 {
39195 arg1 = (int)(SWIG_As_int(obj0));
39196 if (SWIG_arg_fail(1)) SWIG_fail;
39197 }
39198 }
39199 {
39200 PyThreadState* __tstate = wxPyBeginAllowThreads();
39201 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39202
39203 wxPyEndAllowThreads(__tstate);
39204 if (PyErr_Occurred()) SWIG_fail;
39205 }
39206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39207 return resultobj;
39208 fail:
39209 return NULL;
39210 }
39211
39212
39213 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39214 PyObject *resultobj;
39215 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39216 int result;
39217 PyObject * obj0 = 0 ;
39218 char *kwnames[] = {
39219 (char *) "self", NULL
39220 };
39221
39222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39224 if (SWIG_arg_fail(1)) SWIG_fail;
39225 {
39226 PyThreadState* __tstate = wxPyBeginAllowThreads();
39227 result = (int)(arg1)->GetOrientation();
39228
39229 wxPyEndAllowThreads(__tstate);
39230 if (PyErr_Occurred()) SWIG_fail;
39231 }
39232 {
39233 resultobj = SWIG_From_int((int)(result));
39234 }
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39244 int arg2 ;
39245 PyObject * obj0 = 0 ;
39246 PyObject * obj1 = 0 ;
39247 char *kwnames[] = {
39248 (char *) "self",(char *) "orient", NULL
39249 };
39250
39251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39253 if (SWIG_arg_fail(1)) SWIG_fail;
39254 {
39255 arg2 = (int)(SWIG_As_int(obj1));
39256 if (SWIG_arg_fail(2)) SWIG_fail;
39257 }
39258 {
39259 PyThreadState* __tstate = wxPyBeginAllowThreads();
39260 (arg1)->SetOrientation(arg2);
39261
39262 wxPyEndAllowThreads(__tstate);
39263 if (PyErr_Occurred()) SWIG_fail;
39264 }
39265 Py_INCREF(Py_None); resultobj = Py_None;
39266 return resultobj;
39267 fail:
39268 return NULL;
39269 }
39270
39271
39272 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39273 PyObject *obj;
39274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39275 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39276 Py_INCREF(obj);
39277 return Py_BuildValue((char *)"");
39278 }
39279 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39280 PyObject *resultobj;
39281 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39282 int arg2 = (int) wxHORIZONTAL ;
39283 wxStaticBoxSizer *result;
39284 PyObject * obj0 = 0 ;
39285 PyObject * obj1 = 0 ;
39286 char *kwnames[] = {
39287 (char *) "box",(char *) "orient", NULL
39288 };
39289
39290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39292 if (SWIG_arg_fail(1)) SWIG_fail;
39293 if (obj1) {
39294 {
39295 arg2 = (int)(SWIG_As_int(obj1));
39296 if (SWIG_arg_fail(2)) SWIG_fail;
39297 }
39298 }
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39302
39303 wxPyEndAllowThreads(__tstate);
39304 if (PyErr_Occurred()) SWIG_fail;
39305 }
39306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39307 return resultobj;
39308 fail:
39309 return NULL;
39310 }
39311
39312
39313 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj;
39315 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39316 wxStaticBox *result;
39317 PyObject * obj0 = 0 ;
39318 char *kwnames[] = {
39319 (char *) "self", NULL
39320 };
39321
39322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39324 if (SWIG_arg_fail(1)) SWIG_fail;
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxStaticBox *)(arg1)->GetStaticBox();
39328
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 {
39333 resultobj = wxPyMake_wxObject(result, 0);
39334 }
39335 return resultobj;
39336 fail:
39337 return NULL;
39338 }
39339
39340
39341 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39342 PyObject *obj;
39343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39344 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39345 Py_INCREF(obj);
39346 return Py_BuildValue((char *)"");
39347 }
39348 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39349 PyObject *resultobj;
39350 int arg1 = (int) 1 ;
39351 int arg2 = (int) 0 ;
39352 int arg3 = (int) 0 ;
39353 int arg4 = (int) 0 ;
39354 wxGridSizer *result;
39355 PyObject * obj0 = 0 ;
39356 PyObject * obj1 = 0 ;
39357 PyObject * obj2 = 0 ;
39358 PyObject * obj3 = 0 ;
39359 char *kwnames[] = {
39360 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39361 };
39362
39363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39364 if (obj0) {
39365 {
39366 arg1 = (int)(SWIG_As_int(obj0));
39367 if (SWIG_arg_fail(1)) SWIG_fail;
39368 }
39369 }
39370 if (obj1) {
39371 {
39372 arg2 = (int)(SWIG_As_int(obj1));
39373 if (SWIG_arg_fail(2)) SWIG_fail;
39374 }
39375 }
39376 if (obj2) {
39377 {
39378 arg3 = (int)(SWIG_As_int(obj2));
39379 if (SWIG_arg_fail(3)) SWIG_fail;
39380 }
39381 }
39382 if (obj3) {
39383 {
39384 arg4 = (int)(SWIG_As_int(obj3));
39385 if (SWIG_arg_fail(4)) SWIG_fail;
39386 }
39387 }
39388 {
39389 PyThreadState* __tstate = wxPyBeginAllowThreads();
39390 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39391
39392 wxPyEndAllowThreads(__tstate);
39393 if (PyErr_Occurred()) SWIG_fail;
39394 }
39395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39396 return resultobj;
39397 fail:
39398 return NULL;
39399 }
39400
39401
39402 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39403 PyObject *resultobj;
39404 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39405 int arg2 ;
39406 PyObject * obj0 = 0 ;
39407 PyObject * obj1 = 0 ;
39408 char *kwnames[] = {
39409 (char *) "self",(char *) "cols", NULL
39410 };
39411
39412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39414 if (SWIG_arg_fail(1)) SWIG_fail;
39415 {
39416 arg2 = (int)(SWIG_As_int(obj1));
39417 if (SWIG_arg_fail(2)) SWIG_fail;
39418 }
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 (arg1)->SetCols(arg2);
39422
39423 wxPyEndAllowThreads(__tstate);
39424 if (PyErr_Occurred()) SWIG_fail;
39425 }
39426 Py_INCREF(Py_None); resultobj = Py_None;
39427 return resultobj;
39428 fail:
39429 return NULL;
39430 }
39431
39432
39433 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39434 PyObject *resultobj;
39435 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39436 int arg2 ;
39437 PyObject * obj0 = 0 ;
39438 PyObject * obj1 = 0 ;
39439 char *kwnames[] = {
39440 (char *) "self",(char *) "rows", NULL
39441 };
39442
39443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39445 if (SWIG_arg_fail(1)) SWIG_fail;
39446 {
39447 arg2 = (int)(SWIG_As_int(obj1));
39448 if (SWIG_arg_fail(2)) SWIG_fail;
39449 }
39450 {
39451 PyThreadState* __tstate = wxPyBeginAllowThreads();
39452 (arg1)->SetRows(arg2);
39453
39454 wxPyEndAllowThreads(__tstate);
39455 if (PyErr_Occurred()) SWIG_fail;
39456 }
39457 Py_INCREF(Py_None); resultobj = Py_None;
39458 return resultobj;
39459 fail:
39460 return NULL;
39461 }
39462
39463
39464 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39465 PyObject *resultobj;
39466 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39467 int arg2 ;
39468 PyObject * obj0 = 0 ;
39469 PyObject * obj1 = 0 ;
39470 char *kwnames[] = {
39471 (char *) "self",(char *) "gap", NULL
39472 };
39473
39474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39476 if (SWIG_arg_fail(1)) SWIG_fail;
39477 {
39478 arg2 = (int)(SWIG_As_int(obj1));
39479 if (SWIG_arg_fail(2)) SWIG_fail;
39480 }
39481 {
39482 PyThreadState* __tstate = wxPyBeginAllowThreads();
39483 (arg1)->SetVGap(arg2);
39484
39485 wxPyEndAllowThreads(__tstate);
39486 if (PyErr_Occurred()) SWIG_fail;
39487 }
39488 Py_INCREF(Py_None); resultobj = Py_None;
39489 return resultobj;
39490 fail:
39491 return NULL;
39492 }
39493
39494
39495 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39496 PyObject *resultobj;
39497 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39498 int arg2 ;
39499 PyObject * obj0 = 0 ;
39500 PyObject * obj1 = 0 ;
39501 char *kwnames[] = {
39502 (char *) "self",(char *) "gap", NULL
39503 };
39504
39505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39507 if (SWIG_arg_fail(1)) SWIG_fail;
39508 {
39509 arg2 = (int)(SWIG_As_int(obj1));
39510 if (SWIG_arg_fail(2)) SWIG_fail;
39511 }
39512 {
39513 PyThreadState* __tstate = wxPyBeginAllowThreads();
39514 (arg1)->SetHGap(arg2);
39515
39516 wxPyEndAllowThreads(__tstate);
39517 if (PyErr_Occurred()) SWIG_fail;
39518 }
39519 Py_INCREF(Py_None); resultobj = Py_None;
39520 return resultobj;
39521 fail:
39522 return NULL;
39523 }
39524
39525
39526 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39527 PyObject *resultobj;
39528 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39529 int result;
39530 PyObject * obj0 = 0 ;
39531 char *kwnames[] = {
39532 (char *) "self", NULL
39533 };
39534
39535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39537 if (SWIG_arg_fail(1)) SWIG_fail;
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 result = (int)(arg1)->GetCols();
39541
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 {
39546 resultobj = SWIG_From_int((int)(result));
39547 }
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj;
39556 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39557 int result;
39558 PyObject * obj0 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39565 if (SWIG_arg_fail(1)) SWIG_fail;
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (int)(arg1)->GetRows();
39569
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 {
39574 resultobj = SWIG_From_int((int)(result));
39575 }
39576 return resultobj;
39577 fail:
39578 return NULL;
39579 }
39580
39581
39582 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj;
39584 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39585 int result;
39586 PyObject * obj0 = 0 ;
39587 char *kwnames[] = {
39588 (char *) "self", NULL
39589 };
39590
39591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39593 if (SWIG_arg_fail(1)) SWIG_fail;
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 result = (int)(arg1)->GetVGap();
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 {
39602 resultobj = SWIG_From_int((int)(result));
39603 }
39604 return resultobj;
39605 fail:
39606 return NULL;
39607 }
39608
39609
39610 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39611 PyObject *resultobj;
39612 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39613 int result;
39614 PyObject * obj0 = 0 ;
39615 char *kwnames[] = {
39616 (char *) "self", NULL
39617 };
39618
39619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39621 if (SWIG_arg_fail(1)) SWIG_fail;
39622 {
39623 PyThreadState* __tstate = wxPyBeginAllowThreads();
39624 result = (int)(arg1)->GetHGap();
39625
39626 wxPyEndAllowThreads(__tstate);
39627 if (PyErr_Occurred()) SWIG_fail;
39628 }
39629 {
39630 resultobj = SWIG_From_int((int)(result));
39631 }
39632 return resultobj;
39633 fail:
39634 return NULL;
39635 }
39636
39637
39638 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39639 PyObject *obj;
39640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39641 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39642 Py_INCREF(obj);
39643 return Py_BuildValue((char *)"");
39644 }
39645 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39646 PyObject *resultobj;
39647 int arg1 = (int) 1 ;
39648 int arg2 = (int) 0 ;
39649 int arg3 = (int) 0 ;
39650 int arg4 = (int) 0 ;
39651 wxFlexGridSizer *result;
39652 PyObject * obj0 = 0 ;
39653 PyObject * obj1 = 0 ;
39654 PyObject * obj2 = 0 ;
39655 PyObject * obj3 = 0 ;
39656 char *kwnames[] = {
39657 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39658 };
39659
39660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39661 if (obj0) {
39662 {
39663 arg1 = (int)(SWIG_As_int(obj0));
39664 if (SWIG_arg_fail(1)) SWIG_fail;
39665 }
39666 }
39667 if (obj1) {
39668 {
39669 arg2 = (int)(SWIG_As_int(obj1));
39670 if (SWIG_arg_fail(2)) SWIG_fail;
39671 }
39672 }
39673 if (obj2) {
39674 {
39675 arg3 = (int)(SWIG_As_int(obj2));
39676 if (SWIG_arg_fail(3)) SWIG_fail;
39677 }
39678 }
39679 if (obj3) {
39680 {
39681 arg4 = (int)(SWIG_As_int(obj3));
39682 if (SWIG_arg_fail(4)) SWIG_fail;
39683 }
39684 }
39685 {
39686 PyThreadState* __tstate = wxPyBeginAllowThreads();
39687 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39688
39689 wxPyEndAllowThreads(__tstate);
39690 if (PyErr_Occurred()) SWIG_fail;
39691 }
39692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39693 return resultobj;
39694 fail:
39695 return NULL;
39696 }
39697
39698
39699 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39700 PyObject *resultobj;
39701 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39702 size_t arg2 ;
39703 int arg3 = (int) 0 ;
39704 PyObject * obj0 = 0 ;
39705 PyObject * obj1 = 0 ;
39706 PyObject * obj2 = 0 ;
39707 char *kwnames[] = {
39708 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39709 };
39710
39711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39713 if (SWIG_arg_fail(1)) SWIG_fail;
39714 {
39715 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39716 if (SWIG_arg_fail(2)) SWIG_fail;
39717 }
39718 if (obj2) {
39719 {
39720 arg3 = (int)(SWIG_As_int(obj2));
39721 if (SWIG_arg_fail(3)) SWIG_fail;
39722 }
39723 }
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 (arg1)->AddGrowableRow(arg2,arg3);
39727
39728 wxPyEndAllowThreads(__tstate);
39729 if (PyErr_Occurred()) SWIG_fail;
39730 }
39731 Py_INCREF(Py_None); resultobj = Py_None;
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj;
39740 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39741 size_t arg2 ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 char *kwnames[] = {
39745 (char *) "self",(char *) "idx", NULL
39746 };
39747
39748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39750 if (SWIG_arg_fail(1)) SWIG_fail;
39751 {
39752 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39753 if (SWIG_arg_fail(2)) SWIG_fail;
39754 }
39755 {
39756 PyThreadState* __tstate = wxPyBeginAllowThreads();
39757 (arg1)->RemoveGrowableRow(arg2);
39758
39759 wxPyEndAllowThreads(__tstate);
39760 if (PyErr_Occurred()) SWIG_fail;
39761 }
39762 Py_INCREF(Py_None); resultobj = Py_None;
39763 return resultobj;
39764 fail:
39765 return NULL;
39766 }
39767
39768
39769 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39770 PyObject *resultobj;
39771 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39772 size_t arg2 ;
39773 int arg3 = (int) 0 ;
39774 PyObject * obj0 = 0 ;
39775 PyObject * obj1 = 0 ;
39776 PyObject * obj2 = 0 ;
39777 char *kwnames[] = {
39778 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39779 };
39780
39781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39783 if (SWIG_arg_fail(1)) SWIG_fail;
39784 {
39785 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39786 if (SWIG_arg_fail(2)) SWIG_fail;
39787 }
39788 if (obj2) {
39789 {
39790 arg3 = (int)(SWIG_As_int(obj2));
39791 if (SWIG_arg_fail(3)) SWIG_fail;
39792 }
39793 }
39794 {
39795 PyThreadState* __tstate = wxPyBeginAllowThreads();
39796 (arg1)->AddGrowableCol(arg2,arg3);
39797
39798 wxPyEndAllowThreads(__tstate);
39799 if (PyErr_Occurred()) SWIG_fail;
39800 }
39801 Py_INCREF(Py_None); resultobj = Py_None;
39802 return resultobj;
39803 fail:
39804 return NULL;
39805 }
39806
39807
39808 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39809 PyObject *resultobj;
39810 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39811 size_t arg2 ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 char *kwnames[] = {
39815 (char *) "self",(char *) "idx", NULL
39816 };
39817
39818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(1)) SWIG_fail;
39821 {
39822 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39823 if (SWIG_arg_fail(2)) SWIG_fail;
39824 }
39825 {
39826 PyThreadState* __tstate = wxPyBeginAllowThreads();
39827 (arg1)->RemoveGrowableCol(arg2);
39828
39829 wxPyEndAllowThreads(__tstate);
39830 if (PyErr_Occurred()) SWIG_fail;
39831 }
39832 Py_INCREF(Py_None); resultobj = Py_None;
39833 return resultobj;
39834 fail:
39835 return NULL;
39836 }
39837
39838
39839 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39840 PyObject *resultobj;
39841 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39842 int arg2 ;
39843 PyObject * obj0 = 0 ;
39844 PyObject * obj1 = 0 ;
39845 char *kwnames[] = {
39846 (char *) "self",(char *) "direction", NULL
39847 };
39848
39849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39851 if (SWIG_arg_fail(1)) SWIG_fail;
39852 {
39853 arg2 = (int)(SWIG_As_int(obj1));
39854 if (SWIG_arg_fail(2)) SWIG_fail;
39855 }
39856 {
39857 PyThreadState* __tstate = wxPyBeginAllowThreads();
39858 (arg1)->SetFlexibleDirection(arg2);
39859
39860 wxPyEndAllowThreads(__tstate);
39861 if (PyErr_Occurred()) SWIG_fail;
39862 }
39863 Py_INCREF(Py_None); resultobj = Py_None;
39864 return resultobj;
39865 fail:
39866 return NULL;
39867 }
39868
39869
39870 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39871 PyObject *resultobj;
39872 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39873 int result;
39874 PyObject * obj0 = 0 ;
39875 char *kwnames[] = {
39876 (char *) "self", NULL
39877 };
39878
39879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
39880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39881 if (SWIG_arg_fail(1)) SWIG_fail;
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 result = (int)(arg1)->GetFlexibleDirection();
39885
39886 wxPyEndAllowThreads(__tstate);
39887 if (PyErr_Occurred()) SWIG_fail;
39888 }
39889 {
39890 resultobj = SWIG_From_int((int)(result));
39891 }
39892 return resultobj;
39893 fail:
39894 return NULL;
39895 }
39896
39897
39898 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj;
39900 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39901 wxFlexSizerGrowMode arg2 ;
39902 PyObject * obj0 = 0 ;
39903 PyObject * obj1 = 0 ;
39904 char *kwnames[] = {
39905 (char *) "self",(char *) "mode", NULL
39906 };
39907
39908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
39909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39910 if (SWIG_arg_fail(1)) SWIG_fail;
39911 {
39912 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
39913 if (SWIG_arg_fail(2)) SWIG_fail;
39914 }
39915 {
39916 PyThreadState* __tstate = wxPyBeginAllowThreads();
39917 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
39918
39919 wxPyEndAllowThreads(__tstate);
39920 if (PyErr_Occurred()) SWIG_fail;
39921 }
39922 Py_INCREF(Py_None); resultobj = Py_None;
39923 return resultobj;
39924 fail:
39925 return NULL;
39926 }
39927
39928
39929 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39930 PyObject *resultobj;
39931 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39932 wxFlexSizerGrowMode result;
39933 PyObject * obj0 = 0 ;
39934 char *kwnames[] = {
39935 (char *) "self", NULL
39936 };
39937
39938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
39939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39940 if (SWIG_arg_fail(1)) SWIG_fail;
39941 {
39942 PyThreadState* __tstate = wxPyBeginAllowThreads();
39943 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
39944
39945 wxPyEndAllowThreads(__tstate);
39946 if (PyErr_Occurred()) SWIG_fail;
39947 }
39948 resultobj = SWIG_From_int((result));
39949 return resultobj;
39950 fail:
39951 return NULL;
39952 }
39953
39954
39955 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
39956 PyObject *resultobj;
39957 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39958 wxArrayInt *result;
39959 PyObject * obj0 = 0 ;
39960 char *kwnames[] = {
39961 (char *) "self", NULL
39962 };
39963
39964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
39965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39966 if (SWIG_arg_fail(1)) SWIG_fail;
39967 {
39968 PyThreadState* __tstate = wxPyBeginAllowThreads();
39969 {
39970 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
39971 result = (wxArrayInt *) &_result_ref;
39972 }
39973
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 {
39978 resultobj = PyList_New(0);
39979 size_t idx;
39980 for (idx = 0; idx < result->GetCount(); idx += 1) {
39981 PyObject* val = PyInt_FromLong( result->Item(idx) );
39982 PyList_Append(resultobj, val);
39983 Py_DECREF(val);
39984 }
39985 }
39986 return resultobj;
39987 fail:
39988 return NULL;
39989 }
39990
39991
39992 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
39993 PyObject *resultobj;
39994 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39995 wxArrayInt *result;
39996 PyObject * obj0 = 0 ;
39997 char *kwnames[] = {
39998 (char *) "self", NULL
39999 };
40000
40001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40003 if (SWIG_arg_fail(1)) SWIG_fail;
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 {
40007 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40008 result = (wxArrayInt *) &_result_ref;
40009 }
40010
40011 wxPyEndAllowThreads(__tstate);
40012 if (PyErr_Occurred()) SWIG_fail;
40013 }
40014 {
40015 resultobj = PyList_New(0);
40016 size_t idx;
40017 for (idx = 0; idx < result->GetCount(); idx += 1) {
40018 PyObject* val = PyInt_FromLong( result->Item(idx) );
40019 PyList_Append(resultobj, val);
40020 Py_DECREF(val);
40021 }
40022 }
40023 return resultobj;
40024 fail:
40025 return NULL;
40026 }
40027
40028
40029 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40030 PyObject *obj;
40031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40032 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40033 Py_INCREF(obj);
40034 return Py_BuildValue((char *)"");
40035 }
40036 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40037 PyObject *resultobj;
40038 wxStdDialogButtonSizer *result;
40039 char *kwnames[] = {
40040 NULL
40041 };
40042
40043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40047
40048 wxPyEndAllowThreads(__tstate);
40049 if (PyErr_Occurred()) SWIG_fail;
40050 }
40051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40052 return resultobj;
40053 fail:
40054 return NULL;
40055 }
40056
40057
40058 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40059 PyObject *resultobj;
40060 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40061 wxButton *arg2 = (wxButton *) 0 ;
40062 PyObject * obj0 = 0 ;
40063 PyObject * obj1 = 0 ;
40064 char *kwnames[] = {
40065 (char *) "self",(char *) "button", NULL
40066 };
40067
40068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40070 if (SWIG_arg_fail(1)) SWIG_fail;
40071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40072 if (SWIG_arg_fail(2)) SWIG_fail;
40073 {
40074 PyThreadState* __tstate = wxPyBeginAllowThreads();
40075 (arg1)->AddButton(arg2);
40076
40077 wxPyEndAllowThreads(__tstate);
40078 if (PyErr_Occurred()) SWIG_fail;
40079 }
40080 Py_INCREF(Py_None); resultobj = Py_None;
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj;
40089 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40090 PyObject * obj0 = 0 ;
40091 char *kwnames[] = {
40092 (char *) "self", NULL
40093 };
40094
40095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40097 if (SWIG_arg_fail(1)) SWIG_fail;
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 (arg1)->Finalise();
40101
40102 wxPyEndAllowThreads(__tstate);
40103 if (PyErr_Occurred()) SWIG_fail;
40104 }
40105 Py_INCREF(Py_None); resultobj = Py_None;
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj;
40114 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40115 wxButton *result;
40116 PyObject * obj0 = 0 ;
40117 char *kwnames[] = {
40118 (char *) "self", NULL
40119 };
40120
40121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40123 if (SWIG_arg_fail(1)) SWIG_fail;
40124 {
40125 PyThreadState* __tstate = wxPyBeginAllowThreads();
40126 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40127
40128 wxPyEndAllowThreads(__tstate);
40129 if (PyErr_Occurred()) SWIG_fail;
40130 }
40131 {
40132 resultobj = wxPyMake_wxObject(result, 0);
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj;
40142 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40143 wxButton *result;
40144 PyObject * obj0 = 0 ;
40145 char *kwnames[] = {
40146 (char *) "self", NULL
40147 };
40148
40149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40151 if (SWIG_arg_fail(1)) SWIG_fail;
40152 {
40153 PyThreadState* __tstate = wxPyBeginAllowThreads();
40154 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40155
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 {
40160 resultobj = wxPyMake_wxObject(result, 0);
40161 }
40162 return resultobj;
40163 fail:
40164 return NULL;
40165 }
40166
40167
40168 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40169 PyObject *resultobj;
40170 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40171 wxButton *result;
40172 PyObject * obj0 = 0 ;
40173 char *kwnames[] = {
40174 (char *) "self", NULL
40175 };
40176
40177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40179 if (SWIG_arg_fail(1)) SWIG_fail;
40180 {
40181 PyThreadState* __tstate = wxPyBeginAllowThreads();
40182 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40183
40184 wxPyEndAllowThreads(__tstate);
40185 if (PyErr_Occurred()) SWIG_fail;
40186 }
40187 {
40188 resultobj = wxPyMake_wxObject(result, 0);
40189 }
40190 return resultobj;
40191 fail:
40192 return NULL;
40193 }
40194
40195
40196 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40197 PyObject *resultobj;
40198 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40199 wxButton *result;
40200 PyObject * obj0 = 0 ;
40201 char *kwnames[] = {
40202 (char *) "self", NULL
40203 };
40204
40205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40207 if (SWIG_arg_fail(1)) SWIG_fail;
40208 {
40209 PyThreadState* __tstate = wxPyBeginAllowThreads();
40210 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40211
40212 wxPyEndAllowThreads(__tstate);
40213 if (PyErr_Occurred()) SWIG_fail;
40214 }
40215 {
40216 resultobj = wxPyMake_wxObject(result, 0);
40217 }
40218 return resultobj;
40219 fail:
40220 return NULL;
40221 }
40222
40223
40224 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40225 PyObject *resultobj;
40226 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40227 wxButton *result;
40228 PyObject * obj0 = 0 ;
40229 char *kwnames[] = {
40230 (char *) "self", NULL
40231 };
40232
40233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40235 if (SWIG_arg_fail(1)) SWIG_fail;
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40239
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 {
40244 resultobj = wxPyMake_wxObject(result, 0);
40245 }
40246 return resultobj;
40247 fail:
40248 return NULL;
40249 }
40250
40251
40252 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40253 PyObject *obj;
40254 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40255 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40256 Py_INCREF(obj);
40257 return Py_BuildValue((char *)"");
40258 }
40259 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40260 PyObject *resultobj;
40261 int arg1 = (int) 0 ;
40262 int arg2 = (int) 0 ;
40263 wxGBPosition *result;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char *kwnames[] = {
40267 (char *) "row",(char *) "col", NULL
40268 };
40269
40270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40271 if (obj0) {
40272 {
40273 arg1 = (int)(SWIG_As_int(obj0));
40274 if (SWIG_arg_fail(1)) SWIG_fail;
40275 }
40276 }
40277 if (obj1) {
40278 {
40279 arg2 = (int)(SWIG_As_int(obj1));
40280 if (SWIG_arg_fail(2)) SWIG_fail;
40281 }
40282 }
40283 {
40284 PyThreadState* __tstate = wxPyBeginAllowThreads();
40285 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40286
40287 wxPyEndAllowThreads(__tstate);
40288 if (PyErr_Occurred()) SWIG_fail;
40289 }
40290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40291 return resultobj;
40292 fail:
40293 return NULL;
40294 }
40295
40296
40297 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40298 PyObject *resultobj;
40299 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40300 int result;
40301 PyObject * obj0 = 0 ;
40302 char *kwnames[] = {
40303 (char *) "self", NULL
40304 };
40305
40306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40308 if (SWIG_arg_fail(1)) SWIG_fail;
40309 {
40310 PyThreadState* __tstate = wxPyBeginAllowThreads();
40311 result = (int)((wxGBPosition const *)arg1)->GetRow();
40312
40313 wxPyEndAllowThreads(__tstate);
40314 if (PyErr_Occurred()) SWIG_fail;
40315 }
40316 {
40317 resultobj = SWIG_From_int((int)(result));
40318 }
40319 return resultobj;
40320 fail:
40321 return NULL;
40322 }
40323
40324
40325 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40326 PyObject *resultobj;
40327 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40328 int result;
40329 PyObject * obj0 = 0 ;
40330 char *kwnames[] = {
40331 (char *) "self", NULL
40332 };
40333
40334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40336 if (SWIG_arg_fail(1)) SWIG_fail;
40337 {
40338 PyThreadState* __tstate = wxPyBeginAllowThreads();
40339 result = (int)((wxGBPosition const *)arg1)->GetCol();
40340
40341 wxPyEndAllowThreads(__tstate);
40342 if (PyErr_Occurred()) SWIG_fail;
40343 }
40344 {
40345 resultobj = SWIG_From_int((int)(result));
40346 }
40347 return resultobj;
40348 fail:
40349 return NULL;
40350 }
40351
40352
40353 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40354 PyObject *resultobj;
40355 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40356 int arg2 ;
40357 PyObject * obj0 = 0 ;
40358 PyObject * obj1 = 0 ;
40359 char *kwnames[] = {
40360 (char *) "self",(char *) "row", NULL
40361 };
40362
40363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40365 if (SWIG_arg_fail(1)) SWIG_fail;
40366 {
40367 arg2 = (int)(SWIG_As_int(obj1));
40368 if (SWIG_arg_fail(2)) SWIG_fail;
40369 }
40370 {
40371 PyThreadState* __tstate = wxPyBeginAllowThreads();
40372 (arg1)->SetRow(arg2);
40373
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 Py_INCREF(Py_None); resultobj = Py_None;
40378 return resultobj;
40379 fail:
40380 return NULL;
40381 }
40382
40383
40384 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj;
40386 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40387 int arg2 ;
40388 PyObject * obj0 = 0 ;
40389 PyObject * obj1 = 0 ;
40390 char *kwnames[] = {
40391 (char *) "self",(char *) "col", NULL
40392 };
40393
40394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40396 if (SWIG_arg_fail(1)) SWIG_fail;
40397 {
40398 arg2 = (int)(SWIG_As_int(obj1));
40399 if (SWIG_arg_fail(2)) SWIG_fail;
40400 }
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->SetCol(arg2);
40404
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 Py_INCREF(Py_None); resultobj = Py_None;
40409 return resultobj;
40410 fail:
40411 return NULL;
40412 }
40413
40414
40415 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40416 PyObject *resultobj;
40417 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40418 wxGBPosition *arg2 = 0 ;
40419 bool result;
40420 wxGBPosition temp2 ;
40421 PyObject * obj0 = 0 ;
40422 PyObject * obj1 = 0 ;
40423 char *kwnames[] = {
40424 (char *) "self",(char *) "other", NULL
40425 };
40426
40427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40429 if (SWIG_arg_fail(1)) SWIG_fail;
40430 {
40431 arg2 = &temp2;
40432 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40433 }
40434 {
40435 PyThreadState* __tstate = wxPyBeginAllowThreads();
40436 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40437
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40443 }
40444 return resultobj;
40445 fail:
40446 return NULL;
40447 }
40448
40449
40450 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40451 PyObject *resultobj;
40452 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40453 wxGBPosition *arg2 = 0 ;
40454 bool result;
40455 wxGBPosition temp2 ;
40456 PyObject * obj0 = 0 ;
40457 PyObject * obj1 = 0 ;
40458 char *kwnames[] = {
40459 (char *) "self",(char *) "other", NULL
40460 };
40461
40462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40464 if (SWIG_arg_fail(1)) SWIG_fail;
40465 {
40466 arg2 = &temp2;
40467 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40468 }
40469 {
40470 PyThreadState* __tstate = wxPyBeginAllowThreads();
40471 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40472
40473 wxPyEndAllowThreads(__tstate);
40474 if (PyErr_Occurred()) SWIG_fail;
40475 }
40476 {
40477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40478 }
40479 return resultobj;
40480 fail:
40481 return NULL;
40482 }
40483
40484
40485 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40486 PyObject *resultobj;
40487 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40488 int arg2 = (int) 0 ;
40489 int arg3 = (int) 0 ;
40490 PyObject * obj0 = 0 ;
40491 PyObject * obj1 = 0 ;
40492 PyObject * obj2 = 0 ;
40493 char *kwnames[] = {
40494 (char *) "self",(char *) "row",(char *) "col", NULL
40495 };
40496
40497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40499 if (SWIG_arg_fail(1)) SWIG_fail;
40500 if (obj1) {
40501 {
40502 arg2 = (int)(SWIG_As_int(obj1));
40503 if (SWIG_arg_fail(2)) SWIG_fail;
40504 }
40505 }
40506 if (obj2) {
40507 {
40508 arg3 = (int)(SWIG_As_int(obj2));
40509 if (SWIG_arg_fail(3)) SWIG_fail;
40510 }
40511 }
40512 {
40513 PyThreadState* __tstate = wxPyBeginAllowThreads();
40514 wxGBPosition_Set(arg1,arg2,arg3);
40515
40516 wxPyEndAllowThreads(__tstate);
40517 if (PyErr_Occurred()) SWIG_fail;
40518 }
40519 Py_INCREF(Py_None); resultobj = Py_None;
40520 return resultobj;
40521 fail:
40522 return NULL;
40523 }
40524
40525
40526 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40527 PyObject *resultobj;
40528 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40529 PyObject *result;
40530 PyObject * obj0 = 0 ;
40531 char *kwnames[] = {
40532 (char *) "self", NULL
40533 };
40534
40535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40537 if (SWIG_arg_fail(1)) SWIG_fail;
40538 {
40539 PyThreadState* __tstate = wxPyBeginAllowThreads();
40540 result = (PyObject *)wxGBPosition_Get(arg1);
40541
40542 wxPyEndAllowThreads(__tstate);
40543 if (PyErr_Occurred()) SWIG_fail;
40544 }
40545 resultobj = result;
40546 return resultobj;
40547 fail:
40548 return NULL;
40549 }
40550
40551
40552 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40553 PyObject *obj;
40554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40555 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40556 Py_INCREF(obj);
40557 return Py_BuildValue((char *)"");
40558 }
40559 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40560 PyObject *resultobj;
40561 int arg1 = (int) 1 ;
40562 int arg2 = (int) 1 ;
40563 wxGBSpan *result;
40564 PyObject * obj0 = 0 ;
40565 PyObject * obj1 = 0 ;
40566 char *kwnames[] = {
40567 (char *) "rowspan",(char *) "colspan", NULL
40568 };
40569
40570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40571 if (obj0) {
40572 {
40573 arg1 = (int)(SWIG_As_int(obj0));
40574 if (SWIG_arg_fail(1)) SWIG_fail;
40575 }
40576 }
40577 if (obj1) {
40578 {
40579 arg2 = (int)(SWIG_As_int(obj1));
40580 if (SWIG_arg_fail(2)) SWIG_fail;
40581 }
40582 }
40583 {
40584 PyThreadState* __tstate = wxPyBeginAllowThreads();
40585 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40586
40587 wxPyEndAllowThreads(__tstate);
40588 if (PyErr_Occurred()) SWIG_fail;
40589 }
40590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40591 return resultobj;
40592 fail:
40593 return NULL;
40594 }
40595
40596
40597 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40598 PyObject *resultobj;
40599 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40600 int result;
40601 PyObject * obj0 = 0 ;
40602 char *kwnames[] = {
40603 (char *) "self", NULL
40604 };
40605
40606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40608 if (SWIG_arg_fail(1)) SWIG_fail;
40609 {
40610 PyThreadState* __tstate = wxPyBeginAllowThreads();
40611 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40612
40613 wxPyEndAllowThreads(__tstate);
40614 if (PyErr_Occurred()) SWIG_fail;
40615 }
40616 {
40617 resultobj = SWIG_From_int((int)(result));
40618 }
40619 return resultobj;
40620 fail:
40621 return NULL;
40622 }
40623
40624
40625 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40626 PyObject *resultobj;
40627 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40628 int result;
40629 PyObject * obj0 = 0 ;
40630 char *kwnames[] = {
40631 (char *) "self", NULL
40632 };
40633
40634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40636 if (SWIG_arg_fail(1)) SWIG_fail;
40637 {
40638 PyThreadState* __tstate = wxPyBeginAllowThreads();
40639 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40640
40641 wxPyEndAllowThreads(__tstate);
40642 if (PyErr_Occurred()) SWIG_fail;
40643 }
40644 {
40645 resultobj = SWIG_From_int((int)(result));
40646 }
40647 return resultobj;
40648 fail:
40649 return NULL;
40650 }
40651
40652
40653 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40654 PyObject *resultobj;
40655 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40656 int arg2 ;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 char *kwnames[] = {
40660 (char *) "self",(char *) "rowspan", NULL
40661 };
40662
40663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40665 if (SWIG_arg_fail(1)) SWIG_fail;
40666 {
40667 arg2 = (int)(SWIG_As_int(obj1));
40668 if (SWIG_arg_fail(2)) SWIG_fail;
40669 }
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 (arg1)->SetRowspan(arg2);
40673
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 Py_INCREF(Py_None); resultobj = Py_None;
40678 return resultobj;
40679 fail:
40680 return NULL;
40681 }
40682
40683
40684 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40685 PyObject *resultobj;
40686 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40687 int arg2 ;
40688 PyObject * obj0 = 0 ;
40689 PyObject * obj1 = 0 ;
40690 char *kwnames[] = {
40691 (char *) "self",(char *) "colspan", NULL
40692 };
40693
40694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40696 if (SWIG_arg_fail(1)) SWIG_fail;
40697 {
40698 arg2 = (int)(SWIG_As_int(obj1));
40699 if (SWIG_arg_fail(2)) SWIG_fail;
40700 }
40701 {
40702 PyThreadState* __tstate = wxPyBeginAllowThreads();
40703 (arg1)->SetColspan(arg2);
40704
40705 wxPyEndAllowThreads(__tstate);
40706 if (PyErr_Occurred()) SWIG_fail;
40707 }
40708 Py_INCREF(Py_None); resultobj = Py_None;
40709 return resultobj;
40710 fail:
40711 return NULL;
40712 }
40713
40714
40715 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40716 PyObject *resultobj;
40717 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40718 wxGBSpan *arg2 = 0 ;
40719 bool result;
40720 wxGBSpan temp2 ;
40721 PyObject * obj0 = 0 ;
40722 PyObject * obj1 = 0 ;
40723 char *kwnames[] = {
40724 (char *) "self",(char *) "other", NULL
40725 };
40726
40727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40729 if (SWIG_arg_fail(1)) SWIG_fail;
40730 {
40731 arg2 = &temp2;
40732 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40733 }
40734 {
40735 PyThreadState* __tstate = wxPyBeginAllowThreads();
40736 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40737
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 {
40742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40743 }
40744 return resultobj;
40745 fail:
40746 return NULL;
40747 }
40748
40749
40750 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40751 PyObject *resultobj;
40752 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40753 wxGBSpan *arg2 = 0 ;
40754 bool result;
40755 wxGBSpan temp2 ;
40756 PyObject * obj0 = 0 ;
40757 PyObject * obj1 = 0 ;
40758 char *kwnames[] = {
40759 (char *) "self",(char *) "other", NULL
40760 };
40761
40762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40764 if (SWIG_arg_fail(1)) SWIG_fail;
40765 {
40766 arg2 = &temp2;
40767 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40768 }
40769 {
40770 PyThreadState* __tstate = wxPyBeginAllowThreads();
40771 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40772
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 {
40777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40778 }
40779 return resultobj;
40780 fail:
40781 return NULL;
40782 }
40783
40784
40785 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40786 PyObject *resultobj;
40787 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40788 int arg2 = (int) 1 ;
40789 int arg3 = (int) 1 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 PyObject * obj2 = 0 ;
40793 char *kwnames[] = {
40794 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
40795 };
40796
40797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40799 if (SWIG_arg_fail(1)) SWIG_fail;
40800 if (obj1) {
40801 {
40802 arg2 = (int)(SWIG_As_int(obj1));
40803 if (SWIG_arg_fail(2)) SWIG_fail;
40804 }
40805 }
40806 if (obj2) {
40807 {
40808 arg3 = (int)(SWIG_As_int(obj2));
40809 if (SWIG_arg_fail(3)) SWIG_fail;
40810 }
40811 }
40812 {
40813 PyThreadState* __tstate = wxPyBeginAllowThreads();
40814 wxGBSpan_Set(arg1,arg2,arg3);
40815
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 Py_INCREF(Py_None); resultobj = Py_None;
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj;
40828 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40829 PyObject *result;
40830 PyObject * obj0 = 0 ;
40831 char *kwnames[] = {
40832 (char *) "self", NULL
40833 };
40834
40835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
40836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40837 if (SWIG_arg_fail(1)) SWIG_fail;
40838 {
40839 PyThreadState* __tstate = wxPyBeginAllowThreads();
40840 result = (PyObject *)wxGBSpan_Get(arg1);
40841
40842 wxPyEndAllowThreads(__tstate);
40843 if (PyErr_Occurred()) SWIG_fail;
40844 }
40845 resultobj = result;
40846 return resultobj;
40847 fail:
40848 return NULL;
40849 }
40850
40851
40852 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
40853 PyObject *obj;
40854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40855 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
40856 Py_INCREF(obj);
40857 return Py_BuildValue((char *)"");
40858 }
40859 static int _wrap_DefaultSpan_set(PyObject *) {
40860 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
40861 return 1;
40862 }
40863
40864
40865 static PyObject *_wrap_DefaultSpan_get(void) {
40866 PyObject *pyobj;
40867
40868 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
40869 return pyobj;
40870 }
40871
40872
40873 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
40874 PyObject *resultobj;
40875 wxGBSizerItem *result;
40876 char *kwnames[] = {
40877 NULL
40878 };
40879
40880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
40881 {
40882 PyThreadState* __tstate = wxPyBeginAllowThreads();
40883 result = (wxGBSizerItem *)new wxGBSizerItem();
40884
40885 wxPyEndAllowThreads(__tstate);
40886 if (PyErr_Occurred()) SWIG_fail;
40887 }
40888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40896 PyObject *resultobj;
40897 wxWindow *arg1 = (wxWindow *) 0 ;
40898 wxGBPosition *arg2 = 0 ;
40899 wxGBSpan *arg3 = 0 ;
40900 int arg4 ;
40901 int arg5 ;
40902 PyObject *arg6 = (PyObject *) NULL ;
40903 wxGBSizerItem *result;
40904 wxGBPosition temp2 ;
40905 wxGBSpan temp3 ;
40906 PyObject * obj0 = 0 ;
40907 PyObject * obj1 = 0 ;
40908 PyObject * obj2 = 0 ;
40909 PyObject * obj3 = 0 ;
40910 PyObject * obj4 = 0 ;
40911 PyObject * obj5 = 0 ;
40912 char *kwnames[] = {
40913 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40914 };
40915
40916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40918 if (SWIG_arg_fail(1)) SWIG_fail;
40919 {
40920 arg2 = &temp2;
40921 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40922 }
40923 {
40924 arg3 = &temp3;
40925 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40926 }
40927 {
40928 arg4 = (int)(SWIG_As_int(obj3));
40929 if (SWIG_arg_fail(4)) SWIG_fail;
40930 }
40931 {
40932 arg5 = (int)(SWIG_As_int(obj4));
40933 if (SWIG_arg_fail(5)) SWIG_fail;
40934 }
40935 if (obj5) {
40936 arg6 = obj5;
40937 }
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40941
40942 wxPyEndAllowThreads(__tstate);
40943 if (PyErr_Occurred()) SWIG_fail;
40944 }
40945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40946 return resultobj;
40947 fail:
40948 return NULL;
40949 }
40950
40951
40952 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40953 PyObject *resultobj;
40954 wxSizer *arg1 = (wxSizer *) 0 ;
40955 wxGBPosition *arg2 = 0 ;
40956 wxGBSpan *arg3 = 0 ;
40957 int arg4 ;
40958 int arg5 ;
40959 PyObject *arg6 = (PyObject *) NULL ;
40960 wxGBSizerItem *result;
40961 wxGBPosition temp2 ;
40962 wxGBSpan temp3 ;
40963 PyObject * obj0 = 0 ;
40964 PyObject * obj1 = 0 ;
40965 PyObject * obj2 = 0 ;
40966 PyObject * obj3 = 0 ;
40967 PyObject * obj4 = 0 ;
40968 PyObject * obj5 = 0 ;
40969 char *kwnames[] = {
40970 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40971 };
40972
40973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40975 if (SWIG_arg_fail(1)) SWIG_fail;
40976 {
40977 arg2 = &temp2;
40978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40979 }
40980 {
40981 arg3 = &temp3;
40982 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40983 }
40984 {
40985 arg4 = (int)(SWIG_As_int(obj3));
40986 if (SWIG_arg_fail(4)) SWIG_fail;
40987 }
40988 {
40989 arg5 = (int)(SWIG_As_int(obj4));
40990 if (SWIG_arg_fail(5)) SWIG_fail;
40991 }
40992 if (obj5) {
40993 arg6 = obj5;
40994 }
40995 {
40996 PyThreadState* __tstate = wxPyBeginAllowThreads();
40997 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40998
40999 wxPyEndAllowThreads(__tstate);
41000 if (PyErr_Occurred()) SWIG_fail;
41001 }
41002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41003 return resultobj;
41004 fail:
41005 return NULL;
41006 }
41007
41008
41009 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41010 PyObject *resultobj;
41011 int arg1 ;
41012 int arg2 ;
41013 wxGBPosition *arg3 = 0 ;
41014 wxGBSpan *arg4 = 0 ;
41015 int arg5 ;
41016 int arg6 ;
41017 PyObject *arg7 = (PyObject *) NULL ;
41018 wxGBSizerItem *result;
41019 wxGBPosition temp3 ;
41020 wxGBSpan temp4 ;
41021 PyObject * obj0 = 0 ;
41022 PyObject * obj1 = 0 ;
41023 PyObject * obj2 = 0 ;
41024 PyObject * obj3 = 0 ;
41025 PyObject * obj4 = 0 ;
41026 PyObject * obj5 = 0 ;
41027 PyObject * obj6 = 0 ;
41028 char *kwnames[] = {
41029 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41030 };
41031
41032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41033 {
41034 arg1 = (int)(SWIG_As_int(obj0));
41035 if (SWIG_arg_fail(1)) SWIG_fail;
41036 }
41037 {
41038 arg2 = (int)(SWIG_As_int(obj1));
41039 if (SWIG_arg_fail(2)) SWIG_fail;
41040 }
41041 {
41042 arg3 = &temp3;
41043 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41044 }
41045 {
41046 arg4 = &temp4;
41047 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41048 }
41049 {
41050 arg5 = (int)(SWIG_As_int(obj4));
41051 if (SWIG_arg_fail(5)) SWIG_fail;
41052 }
41053 {
41054 arg6 = (int)(SWIG_As_int(obj5));
41055 if (SWIG_arg_fail(6)) SWIG_fail;
41056 }
41057 if (obj6) {
41058 arg7 = obj6;
41059 }
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41063
41064 wxPyEndAllowThreads(__tstate);
41065 if (PyErr_Occurred()) SWIG_fail;
41066 }
41067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41068 return resultobj;
41069 fail:
41070 return NULL;
41071 }
41072
41073
41074 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41075 PyObject *resultobj;
41076 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41077 wxGBPosition result;
41078 PyObject * obj0 = 0 ;
41079 char *kwnames[] = {
41080 (char *) "self", NULL
41081 };
41082
41083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41085 if (SWIG_arg_fail(1)) SWIG_fail;
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 result = ((wxGBSizerItem const *)arg1)->GetPos();
41089
41090 wxPyEndAllowThreads(__tstate);
41091 if (PyErr_Occurred()) SWIG_fail;
41092 }
41093 {
41094 wxGBPosition * resultptr;
41095 resultptr = new wxGBPosition((wxGBPosition &)(result));
41096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41097 }
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj;
41106 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41107 wxGBSpan result;
41108 PyObject * obj0 = 0 ;
41109 char *kwnames[] = {
41110 (char *) "self", NULL
41111 };
41112
41113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41115 if (SWIG_arg_fail(1)) SWIG_fail;
41116 {
41117 PyThreadState* __tstate = wxPyBeginAllowThreads();
41118 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41119
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 {
41124 wxGBSpan * resultptr;
41125 resultptr = new wxGBSpan((wxGBSpan &)(result));
41126 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41127 }
41128 return resultobj;
41129 fail:
41130 return NULL;
41131 }
41132
41133
41134 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41135 PyObject *resultobj;
41136 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41137 wxGBPosition *arg2 = 0 ;
41138 bool result;
41139 wxGBPosition temp2 ;
41140 PyObject * obj0 = 0 ;
41141 PyObject * obj1 = 0 ;
41142 char *kwnames[] = {
41143 (char *) "self",(char *) "pos", NULL
41144 };
41145
41146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41148 if (SWIG_arg_fail(1)) SWIG_fail;
41149 {
41150 arg2 = &temp2;
41151 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41152 }
41153 {
41154 PyThreadState* __tstate = wxPyBeginAllowThreads();
41155 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41156
41157 wxPyEndAllowThreads(__tstate);
41158 if (PyErr_Occurred()) SWIG_fail;
41159 }
41160 {
41161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41162 }
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj;
41171 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41172 wxGBSpan *arg2 = 0 ;
41173 bool result;
41174 wxGBSpan temp2 ;
41175 PyObject * obj0 = 0 ;
41176 PyObject * obj1 = 0 ;
41177 char *kwnames[] = {
41178 (char *) "self",(char *) "span", NULL
41179 };
41180
41181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41183 if (SWIG_arg_fail(1)) SWIG_fail;
41184 {
41185 arg2 = &temp2;
41186 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41187 }
41188 {
41189 PyThreadState* __tstate = wxPyBeginAllowThreads();
41190 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41191
41192 wxPyEndAllowThreads(__tstate);
41193 if (PyErr_Occurred()) SWIG_fail;
41194 }
41195 {
41196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41197 }
41198 return resultobj;
41199 fail:
41200 return NULL;
41201 }
41202
41203
41204 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41205 PyObject *resultobj;
41206 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41207 wxGBSizerItem *arg2 = 0 ;
41208 bool result;
41209 PyObject * obj0 = 0 ;
41210 PyObject * obj1 = 0 ;
41211 char *kwnames[] = {
41212 (char *) "self",(char *) "other", NULL
41213 };
41214
41215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41217 if (SWIG_arg_fail(1)) SWIG_fail;
41218 {
41219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41220 if (SWIG_arg_fail(2)) SWIG_fail;
41221 if (arg2 == NULL) {
41222 SWIG_null_ref("wxGBSizerItem");
41223 }
41224 if (SWIG_arg_fail(2)) SWIG_fail;
41225 }
41226 {
41227 PyThreadState* __tstate = wxPyBeginAllowThreads();
41228 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41229
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 {
41234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41235 }
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj;
41244 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41245 wxGBPosition *arg2 = 0 ;
41246 wxGBSpan *arg3 = 0 ;
41247 bool result;
41248 wxGBPosition temp2 ;
41249 wxGBSpan temp3 ;
41250 PyObject * obj0 = 0 ;
41251 PyObject * obj1 = 0 ;
41252 PyObject * obj2 = 0 ;
41253 char *kwnames[] = {
41254 (char *) "self",(char *) "pos",(char *) "span", NULL
41255 };
41256
41257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41259 if (SWIG_arg_fail(1)) SWIG_fail;
41260 {
41261 arg2 = &temp2;
41262 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41263 }
41264 {
41265 arg3 = &temp3;
41266 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41267 }
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41271
41272 wxPyEndAllowThreads(__tstate);
41273 if (PyErr_Occurred()) SWIG_fail;
41274 }
41275 {
41276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41277 }
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41287 wxGBPosition result;
41288 PyObject * obj0 = 0 ;
41289 char *kwnames[] = {
41290 (char *) "self", NULL
41291 };
41292
41293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41295 if (SWIG_arg_fail(1)) SWIG_fail;
41296 {
41297 PyThreadState* __tstate = wxPyBeginAllowThreads();
41298 result = wxGBSizerItem_GetEndPos(arg1);
41299
41300 wxPyEndAllowThreads(__tstate);
41301 if (PyErr_Occurred()) SWIG_fail;
41302 }
41303 {
41304 wxGBPosition * resultptr;
41305 resultptr = new wxGBPosition((wxGBPosition &)(result));
41306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41307 }
41308 return resultobj;
41309 fail:
41310 return NULL;
41311 }
41312
41313
41314 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41315 PyObject *resultobj;
41316 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41317 wxGridBagSizer *result;
41318 PyObject * obj0 = 0 ;
41319 char *kwnames[] = {
41320 (char *) "self", NULL
41321 };
41322
41323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41325 if (SWIG_arg_fail(1)) SWIG_fail;
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41329
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj;
41342 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41343 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41344 PyObject * obj0 = 0 ;
41345 PyObject * obj1 = 0 ;
41346 char *kwnames[] = {
41347 (char *) "self",(char *) "sizer", NULL
41348 };
41349
41350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41352 if (SWIG_arg_fail(1)) SWIG_fail;
41353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41354 if (SWIG_arg_fail(2)) SWIG_fail;
41355 {
41356 PyThreadState* __tstate = wxPyBeginAllowThreads();
41357 (arg1)->SetGBSizer(arg2);
41358
41359 wxPyEndAllowThreads(__tstate);
41360 if (PyErr_Occurred()) SWIG_fail;
41361 }
41362 Py_INCREF(Py_None); resultobj = Py_None;
41363 return resultobj;
41364 fail:
41365 return NULL;
41366 }
41367
41368
41369 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41370 PyObject *obj;
41371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41372 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41373 Py_INCREF(obj);
41374 return Py_BuildValue((char *)"");
41375 }
41376 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41377 PyObject *resultobj;
41378 int arg1 = (int) 0 ;
41379 int arg2 = (int) 0 ;
41380 wxGridBagSizer *result;
41381 PyObject * obj0 = 0 ;
41382 PyObject * obj1 = 0 ;
41383 char *kwnames[] = {
41384 (char *) "vgap",(char *) "hgap", NULL
41385 };
41386
41387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41388 if (obj0) {
41389 {
41390 arg1 = (int)(SWIG_As_int(obj0));
41391 if (SWIG_arg_fail(1)) SWIG_fail;
41392 }
41393 }
41394 if (obj1) {
41395 {
41396 arg2 = (int)(SWIG_As_int(obj1));
41397 if (SWIG_arg_fail(2)) SWIG_fail;
41398 }
41399 }
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41403
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj;
41416 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41417 PyObject *arg2 = (PyObject *) 0 ;
41418 wxGBPosition *arg3 = 0 ;
41419 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41420 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41421 int arg5 = (int) 0 ;
41422 int arg6 = (int) 0 ;
41423 PyObject *arg7 = (PyObject *) NULL ;
41424 wxGBSizerItem *result;
41425 wxGBPosition temp3 ;
41426 wxGBSpan temp4 ;
41427 PyObject * obj0 = 0 ;
41428 PyObject * obj1 = 0 ;
41429 PyObject * obj2 = 0 ;
41430 PyObject * obj3 = 0 ;
41431 PyObject * obj4 = 0 ;
41432 PyObject * obj5 = 0 ;
41433 PyObject * obj6 = 0 ;
41434 char *kwnames[] = {
41435 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41436 };
41437
41438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41440 if (SWIG_arg_fail(1)) SWIG_fail;
41441 arg2 = obj1;
41442 {
41443 arg3 = &temp3;
41444 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41445 }
41446 if (obj3) {
41447 {
41448 arg4 = &temp4;
41449 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41450 }
41451 }
41452 if (obj4) {
41453 {
41454 arg5 = (int)(SWIG_As_int(obj4));
41455 if (SWIG_arg_fail(5)) SWIG_fail;
41456 }
41457 }
41458 if (obj5) {
41459 {
41460 arg6 = (int)(SWIG_As_int(obj5));
41461 if (SWIG_arg_fail(6)) SWIG_fail;
41462 }
41463 }
41464 if (obj6) {
41465 arg7 = obj6;
41466 }
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41470
41471 wxPyEndAllowThreads(__tstate);
41472 if (PyErr_Occurred()) SWIG_fail;
41473 }
41474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj;
41483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41484 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41485 wxGBSizerItem *result;
41486 PyObject * obj0 = 0 ;
41487 PyObject * obj1 = 0 ;
41488 char *kwnames[] = {
41489 (char *) "self",(char *) "item", NULL
41490 };
41491
41492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41494 if (SWIG_arg_fail(1)) SWIG_fail;
41495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41496 if (SWIG_arg_fail(2)) SWIG_fail;
41497 {
41498 PyThreadState* __tstate = wxPyBeginAllowThreads();
41499 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41500
41501 wxPyEndAllowThreads(__tstate);
41502 if (PyErr_Occurred()) SWIG_fail;
41503 }
41504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41505 return resultobj;
41506 fail:
41507 return NULL;
41508 }
41509
41510
41511 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj;
41513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41514 int arg2 ;
41515 int arg3 ;
41516 wxSize result;
41517 PyObject * obj0 = 0 ;
41518 PyObject * obj1 = 0 ;
41519 PyObject * obj2 = 0 ;
41520 char *kwnames[] = {
41521 (char *) "self",(char *) "row",(char *) "col", NULL
41522 };
41523
41524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41526 if (SWIG_arg_fail(1)) SWIG_fail;
41527 {
41528 arg2 = (int)(SWIG_As_int(obj1));
41529 if (SWIG_arg_fail(2)) SWIG_fail;
41530 }
41531 {
41532 arg3 = (int)(SWIG_As_int(obj2));
41533 if (SWIG_arg_fail(3)) SWIG_fail;
41534 }
41535 {
41536 PyThreadState* __tstate = wxPyBeginAllowThreads();
41537 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41538
41539 wxPyEndAllowThreads(__tstate);
41540 if (PyErr_Occurred()) SWIG_fail;
41541 }
41542 {
41543 wxSize * resultptr;
41544 resultptr = new wxSize((wxSize &)(result));
41545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41546 }
41547 return resultobj;
41548 fail:
41549 return NULL;
41550 }
41551
41552
41553 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41554 PyObject *resultobj;
41555 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41556 wxSize result;
41557 PyObject * obj0 = 0 ;
41558 char *kwnames[] = {
41559 (char *) "self", NULL
41560 };
41561
41562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41564 if (SWIG_arg_fail(1)) SWIG_fail;
41565 {
41566 PyThreadState* __tstate = wxPyBeginAllowThreads();
41567 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41568
41569 wxPyEndAllowThreads(__tstate);
41570 if (PyErr_Occurred()) SWIG_fail;
41571 }
41572 {
41573 wxSize * resultptr;
41574 resultptr = new wxSize((wxSize &)(result));
41575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj;
41585 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41586 wxSize *arg2 = 0 ;
41587 wxSize temp2 ;
41588 PyObject * obj0 = 0 ;
41589 PyObject * obj1 = 0 ;
41590 char *kwnames[] = {
41591 (char *) "self",(char *) "sz", NULL
41592 };
41593
41594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41596 if (SWIG_arg_fail(1)) SWIG_fail;
41597 {
41598 arg2 = &temp2;
41599 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41600 }
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41604
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 Py_INCREF(Py_None); resultobj = Py_None;
41609 return resultobj;
41610 fail:
41611 return NULL;
41612 }
41613
41614
41615 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41616 PyObject *resultobj;
41617 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41618 wxWindow *arg2 = (wxWindow *) 0 ;
41619 wxGBPosition result;
41620 PyObject * obj0 = 0 ;
41621 PyObject * obj1 = 0 ;
41622
41623 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41625 if (SWIG_arg_fail(1)) SWIG_fail;
41626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41627 if (SWIG_arg_fail(2)) SWIG_fail;
41628 {
41629 PyThreadState* __tstate = wxPyBeginAllowThreads();
41630 result = (arg1)->GetItemPosition(arg2);
41631
41632 wxPyEndAllowThreads(__tstate);
41633 if (PyErr_Occurred()) SWIG_fail;
41634 }
41635 {
41636 wxGBPosition * resultptr;
41637 resultptr = new wxGBPosition((wxGBPosition &)(result));
41638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41639 }
41640 return resultobj;
41641 fail:
41642 return NULL;
41643 }
41644
41645
41646 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41647 PyObject *resultobj;
41648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41649 wxSizer *arg2 = (wxSizer *) 0 ;
41650 wxGBPosition result;
41651 PyObject * obj0 = 0 ;
41652 PyObject * obj1 = 0 ;
41653
41654 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41656 if (SWIG_arg_fail(1)) SWIG_fail;
41657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41658 if (SWIG_arg_fail(2)) SWIG_fail;
41659 {
41660 PyThreadState* __tstate = wxPyBeginAllowThreads();
41661 result = (arg1)->GetItemPosition(arg2);
41662
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 {
41667 wxGBPosition * resultptr;
41668 resultptr = new wxGBPosition((wxGBPosition &)(result));
41669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41670 }
41671 return resultobj;
41672 fail:
41673 return NULL;
41674 }
41675
41676
41677 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41678 PyObject *resultobj;
41679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41680 size_t arg2 ;
41681 wxGBPosition result;
41682 PyObject * obj0 = 0 ;
41683 PyObject * obj1 = 0 ;
41684
41685 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41687 if (SWIG_arg_fail(1)) SWIG_fail;
41688 {
41689 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41690 if (SWIG_arg_fail(2)) SWIG_fail;
41691 }
41692 {
41693 PyThreadState* __tstate = wxPyBeginAllowThreads();
41694 result = (arg1)->GetItemPosition(arg2);
41695
41696 wxPyEndAllowThreads(__tstate);
41697 if (PyErr_Occurred()) SWIG_fail;
41698 }
41699 {
41700 wxGBPosition * resultptr;
41701 resultptr = new wxGBPosition((wxGBPosition &)(result));
41702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41703 }
41704 return resultobj;
41705 fail:
41706 return NULL;
41707 }
41708
41709
41710 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41711 int argc;
41712 PyObject *argv[3];
41713 int ii;
41714
41715 argc = PyObject_Length(args);
41716 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41717 argv[ii] = PyTuple_GetItem(args,ii);
41718 }
41719 if (argc == 2) {
41720 int _v;
41721 {
41722 void *ptr;
41723 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41724 _v = 0;
41725 PyErr_Clear();
41726 } else {
41727 _v = 1;
41728 }
41729 }
41730 if (_v) {
41731 {
41732 void *ptr;
41733 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41734 _v = 0;
41735 PyErr_Clear();
41736 } else {
41737 _v = 1;
41738 }
41739 }
41740 if (_v) {
41741 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41742 }
41743 }
41744 }
41745 if (argc == 2) {
41746 int _v;
41747 {
41748 void *ptr;
41749 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41750 _v = 0;
41751 PyErr_Clear();
41752 } else {
41753 _v = 1;
41754 }
41755 }
41756 if (_v) {
41757 {
41758 void *ptr;
41759 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41760 _v = 0;
41761 PyErr_Clear();
41762 } else {
41763 _v = 1;
41764 }
41765 }
41766 if (_v) {
41767 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41768 }
41769 }
41770 }
41771 if (argc == 2) {
41772 int _v;
41773 {
41774 void *ptr;
41775 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41776 _v = 0;
41777 PyErr_Clear();
41778 } else {
41779 _v = 1;
41780 }
41781 }
41782 if (_v) {
41783 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41784 if (_v) {
41785 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
41786 }
41787 }
41788 }
41789
41790 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
41791 return NULL;
41792 }
41793
41794
41795 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41796 PyObject *resultobj;
41797 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41798 wxWindow *arg2 = (wxWindow *) 0 ;
41799 wxGBPosition *arg3 = 0 ;
41800 bool result;
41801 wxGBPosition temp3 ;
41802 PyObject * obj0 = 0 ;
41803 PyObject * obj1 = 0 ;
41804 PyObject * obj2 = 0 ;
41805
41806 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41808 if (SWIG_arg_fail(1)) SWIG_fail;
41809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41810 if (SWIG_arg_fail(2)) SWIG_fail;
41811 {
41812 arg3 = &temp3;
41813 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41814 }
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41818
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 {
41823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41824 }
41825 return resultobj;
41826 fail:
41827 return NULL;
41828 }
41829
41830
41831 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41832 PyObject *resultobj;
41833 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41834 wxSizer *arg2 = (wxSizer *) 0 ;
41835 wxGBPosition *arg3 = 0 ;
41836 bool result;
41837 wxGBPosition temp3 ;
41838 PyObject * obj0 = 0 ;
41839 PyObject * obj1 = 0 ;
41840 PyObject * obj2 = 0 ;
41841
41842 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41844 if (SWIG_arg_fail(1)) SWIG_fail;
41845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41846 if (SWIG_arg_fail(2)) SWIG_fail;
41847 {
41848 arg3 = &temp3;
41849 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41850 }
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41854
41855 wxPyEndAllowThreads(__tstate);
41856 if (PyErr_Occurred()) SWIG_fail;
41857 }
41858 {
41859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41860 }
41861 return resultobj;
41862 fail:
41863 return NULL;
41864 }
41865
41866
41867 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41868 PyObject *resultobj;
41869 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41870 size_t arg2 ;
41871 wxGBPosition *arg3 = 0 ;
41872 bool result;
41873 wxGBPosition temp3 ;
41874 PyObject * obj0 = 0 ;
41875 PyObject * obj1 = 0 ;
41876 PyObject * obj2 = 0 ;
41877
41878 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41880 if (SWIG_arg_fail(1)) SWIG_fail;
41881 {
41882 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41883 if (SWIG_arg_fail(2)) SWIG_fail;
41884 }
41885 {
41886 arg3 = &temp3;
41887 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41892
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 {
41897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41898 }
41899 return resultobj;
41900 fail:
41901 return NULL;
41902 }
41903
41904
41905 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
41906 int argc;
41907 PyObject *argv[4];
41908 int ii;
41909
41910 argc = PyObject_Length(args);
41911 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
41912 argv[ii] = PyTuple_GetItem(args,ii);
41913 }
41914 if (argc == 3) {
41915 int _v;
41916 {
41917 void *ptr;
41918 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41919 _v = 0;
41920 PyErr_Clear();
41921 } else {
41922 _v = 1;
41923 }
41924 }
41925 if (_v) {
41926 {
41927 void *ptr;
41928 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41929 _v = 0;
41930 PyErr_Clear();
41931 } else {
41932 _v = 1;
41933 }
41934 }
41935 if (_v) {
41936 {
41937 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41938 }
41939 if (_v) {
41940 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
41941 }
41942 }
41943 }
41944 }
41945 if (argc == 3) {
41946 int _v;
41947 {
41948 void *ptr;
41949 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41950 _v = 0;
41951 PyErr_Clear();
41952 } else {
41953 _v = 1;
41954 }
41955 }
41956 if (_v) {
41957 {
41958 void *ptr;
41959 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41960 _v = 0;
41961 PyErr_Clear();
41962 } else {
41963 _v = 1;
41964 }
41965 }
41966 if (_v) {
41967 {
41968 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41969 }
41970 if (_v) {
41971 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
41972 }
41973 }
41974 }
41975 }
41976 if (argc == 3) {
41977 int _v;
41978 {
41979 void *ptr;
41980 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41981 _v = 0;
41982 PyErr_Clear();
41983 } else {
41984 _v = 1;
41985 }
41986 }
41987 if (_v) {
41988 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41989 if (_v) {
41990 {
41991 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41992 }
41993 if (_v) {
41994 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
41995 }
41996 }
41997 }
41998 }
41999
42000 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42001 return NULL;
42002 }
42003
42004
42005 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42006 PyObject *resultobj;
42007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42008 wxWindow *arg2 = (wxWindow *) 0 ;
42009 wxGBSpan result;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012
42013 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42015 if (SWIG_arg_fail(1)) SWIG_fail;
42016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42017 if (SWIG_arg_fail(2)) SWIG_fail;
42018 {
42019 PyThreadState* __tstate = wxPyBeginAllowThreads();
42020 result = (arg1)->GetItemSpan(arg2);
42021
42022 wxPyEndAllowThreads(__tstate);
42023 if (PyErr_Occurred()) SWIG_fail;
42024 }
42025 {
42026 wxGBSpan * resultptr;
42027 resultptr = new wxGBSpan((wxGBSpan &)(result));
42028 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42029 }
42030 return resultobj;
42031 fail:
42032 return NULL;
42033 }
42034
42035
42036 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42037 PyObject *resultobj;
42038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42039 wxSizer *arg2 = (wxSizer *) 0 ;
42040 wxGBSpan result;
42041 PyObject * obj0 = 0 ;
42042 PyObject * obj1 = 0 ;
42043
42044 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42046 if (SWIG_arg_fail(1)) SWIG_fail;
42047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42048 if (SWIG_arg_fail(2)) SWIG_fail;
42049 {
42050 PyThreadState* __tstate = wxPyBeginAllowThreads();
42051 result = (arg1)->GetItemSpan(arg2);
42052
42053 wxPyEndAllowThreads(__tstate);
42054 if (PyErr_Occurred()) SWIG_fail;
42055 }
42056 {
42057 wxGBSpan * resultptr;
42058 resultptr = new wxGBSpan((wxGBSpan &)(result));
42059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42060 }
42061 return resultobj;
42062 fail:
42063 return NULL;
42064 }
42065
42066
42067 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42068 PyObject *resultobj;
42069 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42070 size_t arg2 ;
42071 wxGBSpan result;
42072 PyObject * obj0 = 0 ;
42073 PyObject * obj1 = 0 ;
42074
42075 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42077 if (SWIG_arg_fail(1)) SWIG_fail;
42078 {
42079 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42080 if (SWIG_arg_fail(2)) SWIG_fail;
42081 }
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (arg1)->GetItemSpan(arg2);
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 wxGBSpan * resultptr;
42091 resultptr = new wxGBSpan((wxGBSpan &)(result));
42092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42093 }
42094 return resultobj;
42095 fail:
42096 return NULL;
42097 }
42098
42099
42100 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42101 int argc;
42102 PyObject *argv[3];
42103 int ii;
42104
42105 argc = PyObject_Length(args);
42106 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42107 argv[ii] = PyTuple_GetItem(args,ii);
42108 }
42109 if (argc == 2) {
42110 int _v;
42111 {
42112 void *ptr;
42113 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42114 _v = 0;
42115 PyErr_Clear();
42116 } else {
42117 _v = 1;
42118 }
42119 }
42120 if (_v) {
42121 {
42122 void *ptr;
42123 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42124 _v = 0;
42125 PyErr_Clear();
42126 } else {
42127 _v = 1;
42128 }
42129 }
42130 if (_v) {
42131 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42132 }
42133 }
42134 }
42135 if (argc == 2) {
42136 int _v;
42137 {
42138 void *ptr;
42139 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42140 _v = 0;
42141 PyErr_Clear();
42142 } else {
42143 _v = 1;
42144 }
42145 }
42146 if (_v) {
42147 {
42148 void *ptr;
42149 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42150 _v = 0;
42151 PyErr_Clear();
42152 } else {
42153 _v = 1;
42154 }
42155 }
42156 if (_v) {
42157 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42158 }
42159 }
42160 }
42161 if (argc == 2) {
42162 int _v;
42163 {
42164 void *ptr;
42165 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42166 _v = 0;
42167 PyErr_Clear();
42168 } else {
42169 _v = 1;
42170 }
42171 }
42172 if (_v) {
42173 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42174 if (_v) {
42175 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42176 }
42177 }
42178 }
42179
42180 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42181 return NULL;
42182 }
42183
42184
42185 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42186 PyObject *resultobj;
42187 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42188 wxWindow *arg2 = (wxWindow *) 0 ;
42189 wxGBSpan *arg3 = 0 ;
42190 bool result;
42191 wxGBSpan temp3 ;
42192 PyObject * obj0 = 0 ;
42193 PyObject * obj1 = 0 ;
42194 PyObject * obj2 = 0 ;
42195
42196 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42198 if (SWIG_arg_fail(1)) SWIG_fail;
42199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42200 if (SWIG_arg_fail(2)) SWIG_fail;
42201 {
42202 arg3 = &temp3;
42203 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42204 }
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42208
42209 wxPyEndAllowThreads(__tstate);
42210 if (PyErr_Occurred()) SWIG_fail;
42211 }
42212 {
42213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42214 }
42215 return resultobj;
42216 fail:
42217 return NULL;
42218 }
42219
42220
42221 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42222 PyObject *resultobj;
42223 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42224 wxSizer *arg2 = (wxSizer *) 0 ;
42225 wxGBSpan *arg3 = 0 ;
42226 bool result;
42227 wxGBSpan temp3 ;
42228 PyObject * obj0 = 0 ;
42229 PyObject * obj1 = 0 ;
42230 PyObject * obj2 = 0 ;
42231
42232 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42234 if (SWIG_arg_fail(1)) SWIG_fail;
42235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42236 if (SWIG_arg_fail(2)) SWIG_fail;
42237 {
42238 arg3 = &temp3;
42239 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42240 }
42241 {
42242 PyThreadState* __tstate = wxPyBeginAllowThreads();
42243 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42244
42245 wxPyEndAllowThreads(__tstate);
42246 if (PyErr_Occurred()) SWIG_fail;
42247 }
42248 {
42249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42250 }
42251 return resultobj;
42252 fail:
42253 return NULL;
42254 }
42255
42256
42257 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42258 PyObject *resultobj;
42259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42260 size_t arg2 ;
42261 wxGBSpan *arg3 = 0 ;
42262 bool result;
42263 wxGBSpan temp3 ;
42264 PyObject * obj0 = 0 ;
42265 PyObject * obj1 = 0 ;
42266 PyObject * obj2 = 0 ;
42267
42268 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42270 if (SWIG_arg_fail(1)) SWIG_fail;
42271 {
42272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42273 if (SWIG_arg_fail(2)) SWIG_fail;
42274 }
42275 {
42276 arg3 = &temp3;
42277 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42278 }
42279 {
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42282
42283 wxPyEndAllowThreads(__tstate);
42284 if (PyErr_Occurred()) SWIG_fail;
42285 }
42286 {
42287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42288 }
42289 return resultobj;
42290 fail:
42291 return NULL;
42292 }
42293
42294
42295 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42296 int argc;
42297 PyObject *argv[4];
42298 int ii;
42299
42300 argc = PyObject_Length(args);
42301 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42302 argv[ii] = PyTuple_GetItem(args,ii);
42303 }
42304 if (argc == 3) {
42305 int _v;
42306 {
42307 void *ptr;
42308 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42309 _v = 0;
42310 PyErr_Clear();
42311 } else {
42312 _v = 1;
42313 }
42314 }
42315 if (_v) {
42316 {
42317 void *ptr;
42318 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42319 _v = 0;
42320 PyErr_Clear();
42321 } else {
42322 _v = 1;
42323 }
42324 }
42325 if (_v) {
42326 {
42327 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42328 }
42329 if (_v) {
42330 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42331 }
42332 }
42333 }
42334 }
42335 if (argc == 3) {
42336 int _v;
42337 {
42338 void *ptr;
42339 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42340 _v = 0;
42341 PyErr_Clear();
42342 } else {
42343 _v = 1;
42344 }
42345 }
42346 if (_v) {
42347 {
42348 void *ptr;
42349 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42350 _v = 0;
42351 PyErr_Clear();
42352 } else {
42353 _v = 1;
42354 }
42355 }
42356 if (_v) {
42357 {
42358 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42359 }
42360 if (_v) {
42361 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42362 }
42363 }
42364 }
42365 }
42366 if (argc == 3) {
42367 int _v;
42368 {
42369 void *ptr;
42370 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42371 _v = 0;
42372 PyErr_Clear();
42373 } else {
42374 _v = 1;
42375 }
42376 }
42377 if (_v) {
42378 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42379 if (_v) {
42380 {
42381 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42382 }
42383 if (_v) {
42384 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42385 }
42386 }
42387 }
42388 }
42389
42390 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42391 return NULL;
42392 }
42393
42394
42395 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42396 PyObject *resultobj;
42397 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42398 wxWindow *arg2 = (wxWindow *) 0 ;
42399 wxGBSizerItem *result;
42400 PyObject * obj0 = 0 ;
42401 PyObject * obj1 = 0 ;
42402
42403 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42405 if (SWIG_arg_fail(1)) SWIG_fail;
42406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42407 if (SWIG_arg_fail(2)) SWIG_fail;
42408 {
42409 PyThreadState* __tstate = wxPyBeginAllowThreads();
42410 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42411
42412 wxPyEndAllowThreads(__tstate);
42413 if (PyErr_Occurred()) SWIG_fail;
42414 }
42415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42416 return resultobj;
42417 fail:
42418 return NULL;
42419 }
42420
42421
42422 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42423 PyObject *resultobj;
42424 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42425 wxSizer *arg2 = (wxSizer *) 0 ;
42426 wxGBSizerItem *result;
42427 PyObject * obj0 = 0 ;
42428 PyObject * obj1 = 0 ;
42429
42430 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42432 if (SWIG_arg_fail(1)) SWIG_fail;
42433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42434 if (SWIG_arg_fail(2)) SWIG_fail;
42435 {
42436 PyThreadState* __tstate = wxPyBeginAllowThreads();
42437 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42438
42439 wxPyEndAllowThreads(__tstate);
42440 if (PyErr_Occurred()) SWIG_fail;
42441 }
42442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42443 return resultobj;
42444 fail:
42445 return NULL;
42446 }
42447
42448
42449 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42450 int argc;
42451 PyObject *argv[3];
42452 int ii;
42453
42454 argc = PyObject_Length(args);
42455 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42456 argv[ii] = PyTuple_GetItem(args,ii);
42457 }
42458 if (argc == 2) {
42459 int _v;
42460 {
42461 void *ptr;
42462 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42463 _v = 0;
42464 PyErr_Clear();
42465 } else {
42466 _v = 1;
42467 }
42468 }
42469 if (_v) {
42470 {
42471 void *ptr;
42472 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42473 _v = 0;
42474 PyErr_Clear();
42475 } else {
42476 _v = 1;
42477 }
42478 }
42479 if (_v) {
42480 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42481 }
42482 }
42483 }
42484 if (argc == 2) {
42485 int _v;
42486 {
42487 void *ptr;
42488 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42489 _v = 0;
42490 PyErr_Clear();
42491 } else {
42492 _v = 1;
42493 }
42494 }
42495 if (_v) {
42496 {
42497 void *ptr;
42498 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42499 _v = 0;
42500 PyErr_Clear();
42501 } else {
42502 _v = 1;
42503 }
42504 }
42505 if (_v) {
42506 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42507 }
42508 }
42509 }
42510
42511 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42512 return NULL;
42513 }
42514
42515
42516 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42517 PyObject *resultobj;
42518 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42519 wxGBPosition *arg2 = 0 ;
42520 wxGBSizerItem *result;
42521 wxGBPosition temp2 ;
42522 PyObject * obj0 = 0 ;
42523 PyObject * obj1 = 0 ;
42524 char *kwnames[] = {
42525 (char *) "self",(char *) "pos", NULL
42526 };
42527
42528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42530 if (SWIG_arg_fail(1)) SWIG_fail;
42531 {
42532 arg2 = &temp2;
42533 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42534 }
42535 {
42536 PyThreadState* __tstate = wxPyBeginAllowThreads();
42537 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42538
42539 wxPyEndAllowThreads(__tstate);
42540 if (PyErr_Occurred()) SWIG_fail;
42541 }
42542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42543 return resultobj;
42544 fail:
42545 return NULL;
42546 }
42547
42548
42549 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42550 PyObject *resultobj;
42551 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42552 wxPoint *arg2 = 0 ;
42553 wxGBSizerItem *result;
42554 wxPoint temp2 ;
42555 PyObject * obj0 = 0 ;
42556 PyObject * obj1 = 0 ;
42557 char *kwnames[] = {
42558 (char *) "self",(char *) "pt", NULL
42559 };
42560
42561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42563 if (SWIG_arg_fail(1)) SWIG_fail;
42564 {
42565 arg2 = &temp2;
42566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42567 }
42568 {
42569 PyThreadState* __tstate = wxPyBeginAllowThreads();
42570 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42571
42572 wxPyEndAllowThreads(__tstate);
42573 if (PyErr_Occurred()) SWIG_fail;
42574 }
42575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42576 return resultobj;
42577 fail:
42578 return NULL;
42579 }
42580
42581
42582 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42583 PyObject *resultobj;
42584 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42585 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42586 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42587 bool result;
42588 PyObject * obj0 = 0 ;
42589 PyObject * obj1 = 0 ;
42590 PyObject * obj2 = 0 ;
42591 char *kwnames[] = {
42592 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42593 };
42594
42595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42597 if (SWIG_arg_fail(1)) SWIG_fail;
42598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42599 if (SWIG_arg_fail(2)) SWIG_fail;
42600 if (obj2) {
42601 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42602 if (SWIG_arg_fail(3)) SWIG_fail;
42603 }
42604 {
42605 PyThreadState* __tstate = wxPyBeginAllowThreads();
42606 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42607
42608 wxPyEndAllowThreads(__tstate);
42609 if (PyErr_Occurred()) SWIG_fail;
42610 }
42611 {
42612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42613 }
42614 return resultobj;
42615 fail:
42616 return NULL;
42617 }
42618
42619
42620 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42621 PyObject *resultobj;
42622 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42623 wxGBPosition *arg2 = 0 ;
42624 wxGBSpan *arg3 = 0 ;
42625 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42626 bool result;
42627 wxGBPosition temp2 ;
42628 wxGBSpan temp3 ;
42629 PyObject * obj0 = 0 ;
42630 PyObject * obj1 = 0 ;
42631 PyObject * obj2 = 0 ;
42632 PyObject * obj3 = 0 ;
42633 char *kwnames[] = {
42634 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42635 };
42636
42637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42639 if (SWIG_arg_fail(1)) SWIG_fail;
42640 {
42641 arg2 = &temp2;
42642 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42643 }
42644 {
42645 arg3 = &temp3;
42646 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42647 }
42648 if (obj3) {
42649 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42650 if (SWIG_arg_fail(4)) SWIG_fail;
42651 }
42652 {
42653 PyThreadState* __tstate = wxPyBeginAllowThreads();
42654 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42655
42656 wxPyEndAllowThreads(__tstate);
42657 if (PyErr_Occurred()) SWIG_fail;
42658 }
42659 {
42660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42661 }
42662 return resultobj;
42663 fail:
42664 return NULL;
42665 }
42666
42667
42668 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42669 PyObject *obj;
42670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42671 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42672 Py_INCREF(obj);
42673 return Py_BuildValue((char *)"");
42674 }
42675 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42676 PyObject *resultobj;
42677 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42678 wxRelationship arg2 ;
42679 wxWindow *arg3 = (wxWindow *) 0 ;
42680 wxEdge arg4 ;
42681 int arg5 = (int) 0 ;
42682 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42683 PyObject * obj0 = 0 ;
42684 PyObject * obj1 = 0 ;
42685 PyObject * obj2 = 0 ;
42686 PyObject * obj3 = 0 ;
42687 PyObject * obj4 = 0 ;
42688 PyObject * obj5 = 0 ;
42689 char *kwnames[] = {
42690 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42691 };
42692
42693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42695 if (SWIG_arg_fail(1)) SWIG_fail;
42696 {
42697 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42698 if (SWIG_arg_fail(2)) SWIG_fail;
42699 }
42700 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42701 if (SWIG_arg_fail(3)) SWIG_fail;
42702 {
42703 arg4 = (wxEdge)(SWIG_As_int(obj3));
42704 if (SWIG_arg_fail(4)) SWIG_fail;
42705 }
42706 if (obj4) {
42707 {
42708 arg5 = (int)(SWIG_As_int(obj4));
42709 if (SWIG_arg_fail(5)) SWIG_fail;
42710 }
42711 }
42712 if (obj5) {
42713 {
42714 arg6 = (int)(SWIG_As_int(obj5));
42715 if (SWIG_arg_fail(6)) SWIG_fail;
42716 }
42717 }
42718 {
42719 PyThreadState* __tstate = wxPyBeginAllowThreads();
42720 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42721
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 Py_INCREF(Py_None); resultobj = Py_None;
42726 return resultobj;
42727 fail:
42728 return NULL;
42729 }
42730
42731
42732 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42733 PyObject *resultobj;
42734 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42735 wxWindow *arg2 = (wxWindow *) 0 ;
42736 int arg3 = (int) 0 ;
42737 PyObject * obj0 = 0 ;
42738 PyObject * obj1 = 0 ;
42739 PyObject * obj2 = 0 ;
42740 char *kwnames[] = {
42741 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42742 };
42743
42744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42746 if (SWIG_arg_fail(1)) SWIG_fail;
42747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42748 if (SWIG_arg_fail(2)) SWIG_fail;
42749 if (obj2) {
42750 {
42751 arg3 = (int)(SWIG_As_int(obj2));
42752 if (SWIG_arg_fail(3)) SWIG_fail;
42753 }
42754 }
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 (arg1)->LeftOf(arg2,arg3);
42758
42759 wxPyEndAllowThreads(__tstate);
42760 if (PyErr_Occurred()) SWIG_fail;
42761 }
42762 Py_INCREF(Py_None); resultobj = Py_None;
42763 return resultobj;
42764 fail:
42765 return NULL;
42766 }
42767
42768
42769 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42770 PyObject *resultobj;
42771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42772 wxWindow *arg2 = (wxWindow *) 0 ;
42773 int arg3 = (int) 0 ;
42774 PyObject * obj0 = 0 ;
42775 PyObject * obj1 = 0 ;
42776 PyObject * obj2 = 0 ;
42777 char *kwnames[] = {
42778 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42779 };
42780
42781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42783 if (SWIG_arg_fail(1)) SWIG_fail;
42784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42785 if (SWIG_arg_fail(2)) SWIG_fail;
42786 if (obj2) {
42787 {
42788 arg3 = (int)(SWIG_As_int(obj2));
42789 if (SWIG_arg_fail(3)) SWIG_fail;
42790 }
42791 }
42792 {
42793 PyThreadState* __tstate = wxPyBeginAllowThreads();
42794 (arg1)->RightOf(arg2,arg3);
42795
42796 wxPyEndAllowThreads(__tstate);
42797 if (PyErr_Occurred()) SWIG_fail;
42798 }
42799 Py_INCREF(Py_None); resultobj = Py_None;
42800 return resultobj;
42801 fail:
42802 return NULL;
42803 }
42804
42805
42806 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
42807 PyObject *resultobj;
42808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42809 wxWindow *arg2 = (wxWindow *) 0 ;
42810 int arg3 = (int) 0 ;
42811 PyObject * obj0 = 0 ;
42812 PyObject * obj1 = 0 ;
42813 PyObject * obj2 = 0 ;
42814 char *kwnames[] = {
42815 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42816 };
42817
42818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
42819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42820 if (SWIG_arg_fail(1)) SWIG_fail;
42821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42822 if (SWIG_arg_fail(2)) SWIG_fail;
42823 if (obj2) {
42824 {
42825 arg3 = (int)(SWIG_As_int(obj2));
42826 if (SWIG_arg_fail(3)) SWIG_fail;
42827 }
42828 }
42829 {
42830 PyThreadState* __tstate = wxPyBeginAllowThreads();
42831 (arg1)->Above(arg2,arg3);
42832
42833 wxPyEndAllowThreads(__tstate);
42834 if (PyErr_Occurred()) SWIG_fail;
42835 }
42836 Py_INCREF(Py_None); resultobj = Py_None;
42837 return resultobj;
42838 fail:
42839 return NULL;
42840 }
42841
42842
42843 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
42844 PyObject *resultobj;
42845 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42846 wxWindow *arg2 = (wxWindow *) 0 ;
42847 int arg3 = (int) 0 ;
42848 PyObject * obj0 = 0 ;
42849 PyObject * obj1 = 0 ;
42850 PyObject * obj2 = 0 ;
42851 char *kwnames[] = {
42852 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42853 };
42854
42855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
42856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42857 if (SWIG_arg_fail(1)) SWIG_fail;
42858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(2)) SWIG_fail;
42860 if (obj2) {
42861 {
42862 arg3 = (int)(SWIG_As_int(obj2));
42863 if (SWIG_arg_fail(3)) SWIG_fail;
42864 }
42865 }
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 (arg1)->Below(arg2,arg3);
42869
42870 wxPyEndAllowThreads(__tstate);
42871 if (PyErr_Occurred()) SWIG_fail;
42872 }
42873 Py_INCREF(Py_None); resultobj = Py_None;
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj;
42882 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42883 wxWindow *arg2 = (wxWindow *) 0 ;
42884 wxEdge arg3 ;
42885 int arg4 = (int) 0 ;
42886 PyObject * obj0 = 0 ;
42887 PyObject * obj1 = 0 ;
42888 PyObject * obj2 = 0 ;
42889 PyObject * obj3 = 0 ;
42890 char *kwnames[] = {
42891 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
42892 };
42893
42894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42896 if (SWIG_arg_fail(1)) SWIG_fail;
42897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42898 if (SWIG_arg_fail(2)) SWIG_fail;
42899 {
42900 arg3 = (wxEdge)(SWIG_As_int(obj2));
42901 if (SWIG_arg_fail(3)) SWIG_fail;
42902 }
42903 if (obj3) {
42904 {
42905 arg4 = (int)(SWIG_As_int(obj3));
42906 if (SWIG_arg_fail(4)) SWIG_fail;
42907 }
42908 }
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
42912
42913 wxPyEndAllowThreads(__tstate);
42914 if (PyErr_Occurred()) SWIG_fail;
42915 }
42916 Py_INCREF(Py_None); resultobj = Py_None;
42917 return resultobj;
42918 fail:
42919 return NULL;
42920 }
42921
42922
42923 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
42924 PyObject *resultobj;
42925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42926 wxWindow *arg2 = (wxWindow *) 0 ;
42927 wxEdge arg3 ;
42928 int arg4 ;
42929 PyObject * obj0 = 0 ;
42930 PyObject * obj1 = 0 ;
42931 PyObject * obj2 = 0 ;
42932 PyObject * obj3 = 0 ;
42933 char *kwnames[] = {
42934 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
42935 };
42936
42937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42939 if (SWIG_arg_fail(1)) SWIG_fail;
42940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42941 if (SWIG_arg_fail(2)) SWIG_fail;
42942 {
42943 arg3 = (wxEdge)(SWIG_As_int(obj2));
42944 if (SWIG_arg_fail(3)) SWIG_fail;
42945 }
42946 {
42947 arg4 = (int)(SWIG_As_int(obj3));
42948 if (SWIG_arg_fail(4)) SWIG_fail;
42949 }
42950 {
42951 PyThreadState* __tstate = wxPyBeginAllowThreads();
42952 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
42953
42954 wxPyEndAllowThreads(__tstate);
42955 if (PyErr_Occurred()) SWIG_fail;
42956 }
42957 Py_INCREF(Py_None); resultobj = Py_None;
42958 return resultobj;
42959 fail:
42960 return NULL;
42961 }
42962
42963
42964 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
42965 PyObject *resultobj;
42966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42967 int arg2 ;
42968 PyObject * obj0 = 0 ;
42969 PyObject * obj1 = 0 ;
42970 char *kwnames[] = {
42971 (char *) "self",(char *) "val", NULL
42972 };
42973
42974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
42975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42976 if (SWIG_arg_fail(1)) SWIG_fail;
42977 {
42978 arg2 = (int)(SWIG_As_int(obj1));
42979 if (SWIG_arg_fail(2)) SWIG_fail;
42980 }
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 (arg1)->Absolute(arg2);
42984
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 Py_INCREF(Py_None); resultobj = Py_None;
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
42996 PyObject *resultobj;
42997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42998 PyObject * obj0 = 0 ;
42999 char *kwnames[] = {
43000 (char *) "self", NULL
43001 };
43002
43003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43005 if (SWIG_arg_fail(1)) SWIG_fail;
43006 {
43007 PyThreadState* __tstate = wxPyBeginAllowThreads();
43008 (arg1)->Unconstrained();
43009
43010 wxPyEndAllowThreads(__tstate);
43011 if (PyErr_Occurred()) SWIG_fail;
43012 }
43013 Py_INCREF(Py_None); resultobj = Py_None;
43014 return resultobj;
43015 fail:
43016 return NULL;
43017 }
43018
43019
43020 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43021 PyObject *resultobj;
43022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43023 PyObject * obj0 = 0 ;
43024 char *kwnames[] = {
43025 (char *) "self", NULL
43026 };
43027
43028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43030 if (SWIG_arg_fail(1)) SWIG_fail;
43031 {
43032 PyThreadState* __tstate = wxPyBeginAllowThreads();
43033 (arg1)->AsIs();
43034
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 Py_INCREF(Py_None); resultobj = Py_None;
43039 return resultobj;
43040 fail:
43041 return NULL;
43042 }
43043
43044
43045 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43046 PyObject *resultobj;
43047 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43048 wxWindow *result;
43049 PyObject * obj0 = 0 ;
43050 char *kwnames[] = {
43051 (char *) "self", NULL
43052 };
43053
43054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43056 if (SWIG_arg_fail(1)) SWIG_fail;
43057 {
43058 PyThreadState* __tstate = wxPyBeginAllowThreads();
43059 result = (wxWindow *)(arg1)->GetOtherWindow();
43060
43061 wxPyEndAllowThreads(__tstate);
43062 if (PyErr_Occurred()) SWIG_fail;
43063 }
43064 {
43065 resultobj = wxPyMake_wxObject(result, 0);
43066 }
43067 return resultobj;
43068 fail:
43069 return NULL;
43070 }
43071
43072
43073 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43074 PyObject *resultobj;
43075 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43076 wxEdge result;
43077 PyObject * obj0 = 0 ;
43078 char *kwnames[] = {
43079 (char *) "self", NULL
43080 };
43081
43082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43084 if (SWIG_arg_fail(1)) SWIG_fail;
43085 {
43086 PyThreadState* __tstate = wxPyBeginAllowThreads();
43087 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43088
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 resultobj = SWIG_From_int((result));
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj;
43101 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43102 wxEdge arg2 ;
43103 PyObject * obj0 = 0 ;
43104 PyObject * obj1 = 0 ;
43105 char *kwnames[] = {
43106 (char *) "self",(char *) "which", NULL
43107 };
43108
43109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43111 if (SWIG_arg_fail(1)) SWIG_fail;
43112 {
43113 arg2 = (wxEdge)(SWIG_As_int(obj1));
43114 if (SWIG_arg_fail(2)) SWIG_fail;
43115 }
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 (arg1)->SetEdge((wxEdge )arg2);
43119
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 Py_INCREF(Py_None); resultobj = Py_None;
43124 return resultobj;
43125 fail:
43126 return NULL;
43127 }
43128
43129
43130 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43131 PyObject *resultobj;
43132 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43133 int arg2 ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 char *kwnames[] = {
43137 (char *) "self",(char *) "v", NULL
43138 };
43139
43140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43142 if (SWIG_arg_fail(1)) SWIG_fail;
43143 {
43144 arg2 = (int)(SWIG_As_int(obj1));
43145 if (SWIG_arg_fail(2)) SWIG_fail;
43146 }
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 (arg1)->SetValue(arg2);
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 Py_INCREF(Py_None); resultobj = Py_None;
43155 return resultobj;
43156 fail:
43157 return NULL;
43158 }
43159
43160
43161 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43162 PyObject *resultobj;
43163 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43164 int result;
43165 PyObject * obj0 = 0 ;
43166 char *kwnames[] = {
43167 (char *) "self", NULL
43168 };
43169
43170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43172 if (SWIG_arg_fail(1)) SWIG_fail;
43173 {
43174 PyThreadState* __tstate = wxPyBeginAllowThreads();
43175 result = (int)(arg1)->GetMargin();
43176
43177 wxPyEndAllowThreads(__tstate);
43178 if (PyErr_Occurred()) SWIG_fail;
43179 }
43180 {
43181 resultobj = SWIG_From_int((int)(result));
43182 }
43183 return resultobj;
43184 fail:
43185 return NULL;
43186 }
43187
43188
43189 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43190 PyObject *resultobj;
43191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43192 int arg2 ;
43193 PyObject * obj0 = 0 ;
43194 PyObject * obj1 = 0 ;
43195 char *kwnames[] = {
43196 (char *) "self",(char *) "m", NULL
43197 };
43198
43199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43201 if (SWIG_arg_fail(1)) SWIG_fail;
43202 {
43203 arg2 = (int)(SWIG_As_int(obj1));
43204 if (SWIG_arg_fail(2)) SWIG_fail;
43205 }
43206 {
43207 PyThreadState* __tstate = wxPyBeginAllowThreads();
43208 (arg1)->SetMargin(arg2);
43209
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 Py_INCREF(Py_None); resultobj = Py_None;
43214 return resultobj;
43215 fail:
43216 return NULL;
43217 }
43218
43219
43220 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43221 PyObject *resultobj;
43222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43223 int result;
43224 PyObject * obj0 = 0 ;
43225 char *kwnames[] = {
43226 (char *) "self", NULL
43227 };
43228
43229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43231 if (SWIG_arg_fail(1)) SWIG_fail;
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43235
43236 wxPyEndAllowThreads(__tstate);
43237 if (PyErr_Occurred()) SWIG_fail;
43238 }
43239 {
43240 resultobj = SWIG_From_int((int)(result));
43241 }
43242 return resultobj;
43243 fail:
43244 return NULL;
43245 }
43246
43247
43248 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43249 PyObject *resultobj;
43250 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43251 int result;
43252 PyObject * obj0 = 0 ;
43253 char *kwnames[] = {
43254 (char *) "self", NULL
43255 };
43256
43257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43259 if (SWIG_arg_fail(1)) SWIG_fail;
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43263
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 {
43268 resultobj = SWIG_From_int((int)(result));
43269 }
43270 return resultobj;
43271 fail:
43272 return NULL;
43273 }
43274
43275
43276 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43277 PyObject *resultobj;
43278 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43279 int result;
43280 PyObject * obj0 = 0 ;
43281 char *kwnames[] = {
43282 (char *) "self", NULL
43283 };
43284
43285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43287 if (SWIG_arg_fail(1)) SWIG_fail;
43288 {
43289 PyThreadState* __tstate = wxPyBeginAllowThreads();
43290 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43291
43292 wxPyEndAllowThreads(__tstate);
43293 if (PyErr_Occurred()) SWIG_fail;
43294 }
43295 {
43296 resultobj = SWIG_From_int((int)(result));
43297 }
43298 return resultobj;
43299 fail:
43300 return NULL;
43301 }
43302
43303
43304 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43305 PyObject *resultobj;
43306 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43307 bool result;
43308 PyObject * obj0 = 0 ;
43309 char *kwnames[] = {
43310 (char *) "self", NULL
43311 };
43312
43313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43315 if (SWIG_arg_fail(1)) SWIG_fail;
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43319
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 {
43324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43325 }
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj;
43334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43335 bool arg2 ;
43336 PyObject * obj0 = 0 ;
43337 PyObject * obj1 = 0 ;
43338 char *kwnames[] = {
43339 (char *) "self",(char *) "d", NULL
43340 };
43341
43342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43344 if (SWIG_arg_fail(1)) SWIG_fail;
43345 {
43346 arg2 = (bool)(SWIG_As_bool(obj1));
43347 if (SWIG_arg_fail(2)) SWIG_fail;
43348 }
43349 {
43350 PyThreadState* __tstate = wxPyBeginAllowThreads();
43351 (arg1)->SetDone(arg2);
43352
43353 wxPyEndAllowThreads(__tstate);
43354 if (PyErr_Occurred()) SWIG_fail;
43355 }
43356 Py_INCREF(Py_None); resultobj = Py_None;
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43364 PyObject *resultobj;
43365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43366 wxRelationship result;
43367 PyObject * obj0 = 0 ;
43368 char *kwnames[] = {
43369 (char *) "self", NULL
43370 };
43371
43372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43374 if (SWIG_arg_fail(1)) SWIG_fail;
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (wxRelationship)(arg1)->GetRelationship();
43378
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 resultobj = SWIG_From_int((result));
43383 return resultobj;
43384 fail:
43385 return NULL;
43386 }
43387
43388
43389 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43390 PyObject *resultobj;
43391 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43392 wxRelationship arg2 ;
43393 PyObject * obj0 = 0 ;
43394 PyObject * obj1 = 0 ;
43395 char *kwnames[] = {
43396 (char *) "self",(char *) "r", NULL
43397 };
43398
43399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43401 if (SWIG_arg_fail(1)) SWIG_fail;
43402 {
43403 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43404 if (SWIG_arg_fail(2)) SWIG_fail;
43405 }
43406 {
43407 PyThreadState* __tstate = wxPyBeginAllowThreads();
43408 (arg1)->SetRelationship((wxRelationship )arg2);
43409
43410 wxPyEndAllowThreads(__tstate);
43411 if (PyErr_Occurred()) SWIG_fail;
43412 }
43413 Py_INCREF(Py_None); resultobj = Py_None;
43414 return resultobj;
43415 fail:
43416 return NULL;
43417 }
43418
43419
43420 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43421 PyObject *resultobj;
43422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43423 wxWindow *arg2 = (wxWindow *) 0 ;
43424 bool result;
43425 PyObject * obj0 = 0 ;
43426 PyObject * obj1 = 0 ;
43427 char *kwnames[] = {
43428 (char *) "self",(char *) "otherW", NULL
43429 };
43430
43431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43433 if (SWIG_arg_fail(1)) SWIG_fail;
43434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43435 if (SWIG_arg_fail(2)) SWIG_fail;
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 result = (bool)(arg1)->ResetIfWin(arg2);
43439
43440 wxPyEndAllowThreads(__tstate);
43441 if (PyErr_Occurred()) SWIG_fail;
43442 }
43443 {
43444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43445 }
43446 return resultobj;
43447 fail:
43448 return NULL;
43449 }
43450
43451
43452 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43453 PyObject *resultobj;
43454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43455 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43456 wxWindow *arg3 = (wxWindow *) 0 ;
43457 bool result;
43458 PyObject * obj0 = 0 ;
43459 PyObject * obj1 = 0 ;
43460 PyObject * obj2 = 0 ;
43461 char *kwnames[] = {
43462 (char *) "self",(char *) "constraints",(char *) "win", NULL
43463 };
43464
43465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43467 if (SWIG_arg_fail(1)) SWIG_fail;
43468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43469 if (SWIG_arg_fail(2)) SWIG_fail;
43470 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43471 if (SWIG_arg_fail(3)) SWIG_fail;
43472 {
43473 PyThreadState* __tstate = wxPyBeginAllowThreads();
43474 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43475
43476 wxPyEndAllowThreads(__tstate);
43477 if (PyErr_Occurred()) SWIG_fail;
43478 }
43479 {
43480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43481 }
43482 return resultobj;
43483 fail:
43484 return NULL;
43485 }
43486
43487
43488 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43489 PyObject *resultobj;
43490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43491 wxEdge arg2 ;
43492 wxWindow *arg3 = (wxWindow *) 0 ;
43493 wxWindow *arg4 = (wxWindow *) 0 ;
43494 int result;
43495 PyObject * obj0 = 0 ;
43496 PyObject * obj1 = 0 ;
43497 PyObject * obj2 = 0 ;
43498 PyObject * obj3 = 0 ;
43499 char *kwnames[] = {
43500 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43501 };
43502
43503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43505 if (SWIG_arg_fail(1)) SWIG_fail;
43506 {
43507 arg2 = (wxEdge)(SWIG_As_int(obj1));
43508 if (SWIG_arg_fail(2)) SWIG_fail;
43509 }
43510 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43511 if (SWIG_arg_fail(3)) SWIG_fail;
43512 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43513 if (SWIG_arg_fail(4)) SWIG_fail;
43514 {
43515 PyThreadState* __tstate = wxPyBeginAllowThreads();
43516 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43517
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 {
43522 resultobj = SWIG_From_int((int)(result));
43523 }
43524 return resultobj;
43525 fail:
43526 return NULL;
43527 }
43528
43529
43530 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43531 PyObject *obj;
43532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43533 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43534 Py_INCREF(obj);
43535 return Py_BuildValue((char *)"");
43536 }
43537 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43538 PyObject *resultobj;
43539 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43540 wxIndividualLayoutConstraint *result;
43541 PyObject * obj0 = 0 ;
43542 char *kwnames[] = {
43543 (char *) "self", NULL
43544 };
43545
43546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43548 if (SWIG_arg_fail(1)) SWIG_fail;
43549 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43550
43551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43552 return resultobj;
43553 fail:
43554 return NULL;
43555 }
43556
43557
43558 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43559 PyObject *resultobj;
43560 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43561 wxIndividualLayoutConstraint *result;
43562 PyObject * obj0 = 0 ;
43563 char *kwnames[] = {
43564 (char *) "self", NULL
43565 };
43566
43567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43569 if (SWIG_arg_fail(1)) SWIG_fail;
43570 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43571
43572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43573 return resultobj;
43574 fail:
43575 return NULL;
43576 }
43577
43578
43579 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43580 PyObject *resultobj;
43581 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43582 wxIndividualLayoutConstraint *result;
43583 PyObject * obj0 = 0 ;
43584 char *kwnames[] = {
43585 (char *) "self", NULL
43586 };
43587
43588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43590 if (SWIG_arg_fail(1)) SWIG_fail;
43591 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43592
43593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43594 return resultobj;
43595 fail:
43596 return NULL;
43597 }
43598
43599
43600 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43601 PyObject *resultobj;
43602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43603 wxIndividualLayoutConstraint *result;
43604 PyObject * obj0 = 0 ;
43605 char *kwnames[] = {
43606 (char *) "self", NULL
43607 };
43608
43609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43611 if (SWIG_arg_fail(1)) SWIG_fail;
43612 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43613
43614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43615 return resultobj;
43616 fail:
43617 return NULL;
43618 }
43619
43620
43621 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43622 PyObject *resultobj;
43623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43624 wxIndividualLayoutConstraint *result;
43625 PyObject * obj0 = 0 ;
43626 char *kwnames[] = {
43627 (char *) "self", NULL
43628 };
43629
43630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43632 if (SWIG_arg_fail(1)) SWIG_fail;
43633 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43634
43635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43636 return resultobj;
43637 fail:
43638 return NULL;
43639 }
43640
43641
43642 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43643 PyObject *resultobj;
43644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43645 wxIndividualLayoutConstraint *result;
43646 PyObject * obj0 = 0 ;
43647 char *kwnames[] = {
43648 (char *) "self", NULL
43649 };
43650
43651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43653 if (SWIG_arg_fail(1)) SWIG_fail;
43654 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43655
43656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43657 return resultobj;
43658 fail:
43659 return NULL;
43660 }
43661
43662
43663 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43664 PyObject *resultobj;
43665 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43666 wxIndividualLayoutConstraint *result;
43667 PyObject * obj0 = 0 ;
43668 char *kwnames[] = {
43669 (char *) "self", NULL
43670 };
43671
43672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43674 if (SWIG_arg_fail(1)) SWIG_fail;
43675 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43676
43677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43685 PyObject *resultobj;
43686 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43687 wxIndividualLayoutConstraint *result;
43688 PyObject * obj0 = 0 ;
43689 char *kwnames[] = {
43690 (char *) "self", NULL
43691 };
43692
43693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43695 if (SWIG_arg_fail(1)) SWIG_fail;
43696 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43697
43698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43699 return resultobj;
43700 fail:
43701 return NULL;
43702 }
43703
43704
43705 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43706 PyObject *resultobj;
43707 wxLayoutConstraints *result;
43708 char *kwnames[] = {
43709 NULL
43710 };
43711
43712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43713 {
43714 PyThreadState* __tstate = wxPyBeginAllowThreads();
43715 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43716
43717 wxPyEndAllowThreads(__tstate);
43718 if (PyErr_Occurred()) SWIG_fail;
43719 }
43720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43721 return resultobj;
43722 fail:
43723 return NULL;
43724 }
43725
43726
43727 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43728 PyObject *resultobj;
43729 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43730 wxWindow *arg2 = (wxWindow *) 0 ;
43731 int *arg3 = (int *) 0 ;
43732 bool result;
43733 int temp3 ;
43734 int res3 = 0 ;
43735 PyObject * obj0 = 0 ;
43736 PyObject * obj1 = 0 ;
43737 char *kwnames[] = {
43738 (char *) "self",(char *) "win", NULL
43739 };
43740
43741 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43744 if (SWIG_arg_fail(1)) SWIG_fail;
43745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43746 if (SWIG_arg_fail(2)) SWIG_fail;
43747 {
43748 PyThreadState* __tstate = wxPyBeginAllowThreads();
43749 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43750
43751 wxPyEndAllowThreads(__tstate);
43752 if (PyErr_Occurred()) SWIG_fail;
43753 }
43754 {
43755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43756 }
43757 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43758 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43759 return resultobj;
43760 fail:
43761 return NULL;
43762 }
43763
43764
43765 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43766 PyObject *resultobj;
43767 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43768 bool result;
43769 PyObject * obj0 = 0 ;
43770 char *kwnames[] = {
43771 (char *) "self", NULL
43772 };
43773
43774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43776 if (SWIG_arg_fail(1)) SWIG_fail;
43777 {
43778 PyThreadState* __tstate = wxPyBeginAllowThreads();
43779 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43780
43781 wxPyEndAllowThreads(__tstate);
43782 if (PyErr_Occurred()) SWIG_fail;
43783 }
43784 {
43785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43786 }
43787 return resultobj;
43788 fail:
43789 return NULL;
43790 }
43791
43792
43793 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
43794 PyObject *obj;
43795 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43796 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
43797 Py_INCREF(obj);
43798 return Py_BuildValue((char *)"");
43799 }
43800 static PyMethodDef SwigMethods[] = {
43801 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
43802 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
43803 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
43804 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43805 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
43806 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43807 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43808 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43809 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43810 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43811 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43812 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43813 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43814 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43815 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43816 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
43817 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
43818 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43819 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43820 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43821 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43822 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43823 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
43824 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
43825 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43826 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
43827 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43828 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43829 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43830 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43831 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43832 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43833 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43834 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43835 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43836 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43837 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43838 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43839 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
43840 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43841 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43842 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43843 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43844 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43845 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43846 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43847 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43848 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43849 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43850 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43851 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43852 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43853 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43854 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
43855 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43856 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
43857 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
43858 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
43859 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43860 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43861 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
43862 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43863 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
43864 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43865 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43866 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43867 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43868 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43869 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43870 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43871 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43872 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43873 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43874 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43875 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43876 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43877 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43878 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43879 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43880 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43881 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43882 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43883 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43884 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
43885 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
43886 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
43887 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
43888 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
43889 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
43890 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43891 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43892 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43893 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43894 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
43895 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
43896 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
43897 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43898 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43899 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43900 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43901 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43902 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43903 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43904 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43905 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43906 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43907 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
43908 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
43909 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
43910 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
43911 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43912 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
43913 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
43914 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43915 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43916 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43917 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43918 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
43919 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
43920 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43921 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43922 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
43923 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43924 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43925 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
43926 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
43927 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43928 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43929 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43930 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43931 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43932 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43933 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43934 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43935 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
43936 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43937 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43938 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
43939 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
43940 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
43941 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
43942 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
43943 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
43944 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
43945 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
43946 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
43947 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
43948 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
43949 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43950 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
43951 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
43952 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
43953 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
43954 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
43955 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
43956 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
43957 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43958 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43959 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
43960 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43961 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43962 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43963 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
43964 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
43965 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
43966 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43967 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
43968 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43969 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43970 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43971 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43972 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
43973 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43974 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43975 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43976 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
43977 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
43978 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43979 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43980 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
43981 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
43982 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43983 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43984 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43985 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43986 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
43987 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
43988 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
43989 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
43990 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43991 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43992 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43993 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
43994 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43995 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43996 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43997 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43998 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43999 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44000 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44001 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44002 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44003 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44004 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44005 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44006 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44007 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44008 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44009 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44010 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44011 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44012 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44013 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44014 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44015 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44016 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44017 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44019 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44020 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44023 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44024 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44025 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44027 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44034 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44035 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44037 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44041 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44045 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44049 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44051 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44054 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44069 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44070 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44072 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44080 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44081 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44090 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44094 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44098 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44100 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44102 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44104 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44106 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44108 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44109 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44110 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44112 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44114 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44115 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44116 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44117 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44118 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44119 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44120 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44121 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44122 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44123 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44125 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44127 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44129 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44131 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44133 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44135 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44136 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44137 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44139 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44143 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44153 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44154 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44157 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44160 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44172 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44177 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44179 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44183 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44189 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44252 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44259 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44269 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44295 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44305 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"MoveEvent_m_pos_set", (PyCFunction) _wrap_MoveEvent_m_pos_set, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"MoveEvent_m_pos_get", (PyCFunction) _wrap_MoveEvent_m_pos_get, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"MoveEvent_m_rect_set", (PyCFunction) _wrap_MoveEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"MoveEvent_m_rect_get", (PyCFunction) _wrap_MoveEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44315 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44317 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44319 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44322 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44326 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44329 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44332 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44334 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44339 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44347 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44351 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44354 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44356 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44360 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44377 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44379 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44382 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44384 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44388 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44392 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44401 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44404 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44407 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44411 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44418 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44423 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44428 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44473 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44493 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44500 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44504 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44514 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44683 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44723 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44737 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44740 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
44795 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
44822 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
44852 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
44860 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
44877 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
44878 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
44915 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
44945 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
44948 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
44952 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
44955 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
44965 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
44977 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
44986 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
44996 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45006 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45020 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45027 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45028 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45029 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45030 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45031 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45036 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45063 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45075 { NULL, NULL, 0, NULL }
45076 };
45077
45078
45079 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45080
45081 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45082 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45083 }
45084 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45085 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45086 }
45087 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45088 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45089 }
45090 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45091 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45092 }
45093 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45094 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45095 }
45096 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45097 return (void *)((wxSizer *) ((wxGridSizer *) x));
45098 }
45099 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45100 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45101 }
45102 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45103 return (void *)((wxSizer *) ((wxPySizer *) x));
45104 }
45105 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45106 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45107 }
45108 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45109 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45110 }
45111 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45112 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45113 }
45114 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45115 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45116 }
45117 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45118 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45119 }
45120 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45121 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45122 }
45123 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45124 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45125 }
45126 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45127 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45128 }
45129 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45130 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45131 }
45132 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45133 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45134 }
45135 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45136 return (void *)((wxEvent *) ((wxPyEvent *) x));
45137 }
45138 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45140 }
45141 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45142 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45143 }
45144 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45145 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45146 }
45147 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45148 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45149 }
45150 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45151 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45152 }
45153 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45154 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45155 }
45156 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45157 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45158 }
45159 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45160 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45161 }
45162 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45163 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45164 }
45165 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45166 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45167 }
45168 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45169 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45170 }
45171 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45172 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45173 }
45174 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45175 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45176 }
45177 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45178 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45179 }
45180 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45181 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45182 }
45183 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45184 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45185 }
45186 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45187 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45188 }
45189 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45190 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45191 }
45192 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45194 }
45195 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45196 return (void *)((wxEvent *) ((wxShowEvent *) x));
45197 }
45198 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45199 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45200 }
45201 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45203 }
45204 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45205 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45206 }
45207 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45208 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45209 }
45210 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45211 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45212 }
45213 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45214 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45215 }
45216 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45217 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45218 }
45219 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45220 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45221 }
45222 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45223 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45224 }
45225 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45226 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45227 }
45228 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45229 return (void *)((wxControl *) ((wxControlWithItems *) x));
45230 }
45231 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45232 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45233 }
45234 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45235 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45236 }
45237 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45238 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45239 }
45240 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45241 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45242 }
45243 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45244 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45245 }
45246 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45247 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45248 }
45249 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45250 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45251 }
45252 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45253 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45254 }
45255 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45256 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45257 }
45258 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45259 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45260 }
45261 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45262 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45263 }
45264 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45265 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45266 }
45267 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45268 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45269 }
45270 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45271 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45272 }
45273 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45274 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45275 }
45276 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45277 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45278 }
45279 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45280 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45281 }
45282 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45283 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45284 }
45285 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45286 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45287 }
45288 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45289 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45290 }
45291 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45292 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45293 }
45294 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45295 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45296 }
45297 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45298 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45299 }
45300 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45301 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45302 }
45303 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45304 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45305 }
45306 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45307 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45308 }
45309 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45310 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45311 }
45312 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45313 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45314 }
45315 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45316 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45317 }
45318 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45319 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45320 }
45321 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45322 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45323 }
45324 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45325 return (void *)((wxObject *) ((wxSizerItem *) x));
45326 }
45327 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45329 }
45330 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45331 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45332 }
45333 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45334 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45335 }
45336 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45337 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45338 }
45339 static void *_p_wxSizerTo_p_wxObject(void *x) {
45340 return (void *)((wxObject *) ((wxSizer *) x));
45341 }
45342 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45343 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45344 }
45345 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45346 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45347 }
45348 static void *_p_wxEventTo_p_wxObject(void *x) {
45349 return (void *)((wxObject *) ((wxEvent *) x));
45350 }
45351 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45352 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45353 }
45354 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45355 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45356 }
45357 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45358 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45359 }
45360 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45361 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45362 }
45363 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45364 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45365 }
45366 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45367 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45368 }
45369 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45370 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45371 }
45372 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45373 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45374 }
45375 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45376 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45377 }
45378 static void *_p_wxControlTo_p_wxObject(void *x) {
45379 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45380 }
45381 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45382 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45383 }
45384 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45385 return (void *)((wxObject *) ((wxFSFile *) x));
45386 }
45387 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45388 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45389 }
45390 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45391 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45392 }
45393 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45394 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45395 }
45396 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45397 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45398 }
45399 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45400 return (void *)((wxObject *) ((wxMenuItem *) x));
45401 }
45402 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45403 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45404 }
45405 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45407 }
45408 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45409 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45410 }
45411 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45412 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45413 }
45414 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45415 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45416 }
45417 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45418 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45419 }
45420 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45421 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45422 }
45423 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45424 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45425 }
45426 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45427 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45428 }
45429 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45430 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45431 }
45432 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45433 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45434 }
45435 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45436 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45437 }
45438 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45439 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45440 }
45441 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45442 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45443 }
45444 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45445 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45446 }
45447 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45448 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45449 }
45450 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45451 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45452 }
45453 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45454 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45455 }
45456 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45457 return (void *)((wxObject *) ((wxImageHandler *) x));
45458 }
45459 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45460 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45461 }
45462 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45463 return (void *)((wxObject *) ((wxEvtHandler *) x));
45464 }
45465 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45466 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45467 }
45468 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45469 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45470 }
45471 static void *_p_wxImageTo_p_wxObject(void *x) {
45472 return (void *)((wxObject *) ((wxImage *) x));
45473 }
45474 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45475 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45476 }
45477 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45479 }
45480 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45481 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45482 }
45483 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45484 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45485 }
45486 static void *_p_wxWindowTo_p_wxObject(void *x) {
45487 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45488 }
45489 static void *_p_wxMenuTo_p_wxObject(void *x) {
45490 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45491 }
45492 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45493 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45494 }
45495 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45496 return (void *)((wxObject *) ((wxFileSystem *) x));
45497 }
45498 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45500 }
45501 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45502 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45503 }
45504 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45505 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45506 }
45507 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45508 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45509 }
45510 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45511 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45512 }
45513 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45514 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45515 }
45516 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45517 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45518 }
45519 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45520 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45521 }
45522 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45523 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45524 }
45525 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45526 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45527 }
45528 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45530 }
45531 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45532 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45533 }
45534 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45535 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45536 }
45537 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45538 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45539 }
45540 static void *_p_wxControlTo_p_wxWindow(void *x) {
45541 return (void *)((wxWindow *) ((wxControl *) x));
45542 }
45543 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45544 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45545 }
45546 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45547 return (void *)((wxWindow *) ((wxMenuBar *) x));
45548 }
45549 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45550 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45551 }
45552 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45553 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45554 }
45555 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45556 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45557 }
45558 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45559 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45560 }
45561 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45562 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45563 }
45564 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45565 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45566 }
45567 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45568 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45569 }
45570 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45571 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45572 }
45573 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45574 return (void *)((wxValidator *) ((wxPyValidator *) x));
45575 }
45576 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}};
45577 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}};
45578 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}};
45579 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}};
45580 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}};
45581 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}};
45582 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}};
45583 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}};
45584 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}};
45585 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}};
45586 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}};
45587 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}};
45588 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}};
45589 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45590 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}};
45591 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}};
45592 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}};
45593 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}};
45594 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}};
45595 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}};
45596 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}};
45597 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}};
45598 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}};
45599 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}};
45600 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}};
45601 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}};
45602 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}};
45603 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}};
45604 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}};
45605 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}};
45606 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}};
45607 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}};
45608 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}};
45609 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}};
45610 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}};
45611 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}};
45612 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}};
45613 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}};
45614 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}};
45615 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}};
45616 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}};
45617 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}};
45618 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}};
45619 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}};
45620 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}};
45621 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}};
45622 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}};
45623 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}};
45624 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}};
45625 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}};
45626 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}};
45627 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}};
45628 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}};
45629 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}};
45630 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}};
45631 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}};
45632 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}};
45633 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}};
45634 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}};
45635 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}};
45636 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}};
45637 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}};
45638 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}};
45639 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}};
45640 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}};
45641 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}};
45642 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}};
45643 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}};
45644 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}};
45645 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}};
45646 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}};
45647 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}};
45648 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}};
45649 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}};
45650 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}};
45651 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}};
45652 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}};
45653 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}};
45654 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}};
45655 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}};
45656 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}};
45657 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}};
45658 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}};
45659 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}};
45660 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}};
45661 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}};
45662 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}};
45663 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}};
45664 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}};
45665 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}};
45666 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}};
45667 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}};
45668 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}};
45669 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45670 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}};
45671 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}};
45672 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}};
45673 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}};
45674 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}};
45675 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}};
45676 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}};
45677 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}};
45678 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}};
45679 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}};
45680 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}};
45681 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}};
45682 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}};
45683 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}};
45684 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}};
45685 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}};
45686 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}};
45687 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}};
45688 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}};
45689 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}};
45690 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}};
45691 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45692 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}};
45693 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}};
45694 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}};
45695 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}};
45696 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}};
45697 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}};
45698 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}};
45699 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}};
45700 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}};
45701 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}};
45702
45703 static swig_type_info *swig_types_initial[] = {
45704 _swigt__p_wxLayoutConstraints,
45705 _swigt__p_wxRealPoint,
45706 _swigt__p_wxSizerItem,
45707 _swigt__p_wxGBSizerItem,
45708 _swigt__p_wxScrollEvent,
45709 _swigt__p_wxEventLoop,
45710 _swigt__p_wxIndividualLayoutConstraint,
45711 _swigt__p_wxSizer,
45712 _swigt__p_wxBoxSizer,
45713 _swigt__p_wxStaticBoxSizer,
45714 _swigt__p_wxGridBagSizer,
45715 _swigt__p_wxAcceleratorEntry,
45716 _swigt__p_wxUpdateUIEvent,
45717 _swigt__p_wxEvent,
45718 _swigt__p_wxMenu,
45719 _swigt__p_wxGridSizer,
45720 _swigt__p_wxFlexGridSizer,
45721 _swigt__p_wxInitDialogEvent,
45722 _swigt__p_wxItemContainer,
45723 _swigt__p_wxNcPaintEvent,
45724 _swigt__p_wxPaintEvent,
45725 _swigt__p_wxSysColourChangedEvent,
45726 _swigt__p_wxMouseCaptureChangedEvent,
45727 _swigt__p_wxDisplayChangedEvent,
45728 _swigt__p_wxPaletteChangedEvent,
45729 _swigt__p_wxControl,
45730 _swigt__p_wxFont,
45731 _swigt__p_wxMenuBarBase,
45732 _swigt__p_wxSetCursorEvent,
45733 _swigt__p_wxFSFile,
45734 _swigt__p_wxCaret,
45735 _swigt__ptrdiff_t,
45736 _swigt__std__ptrdiff_t,
45737 _swigt__p_wxRegion,
45738 _swigt__p_wxPoint2D,
45739 _swigt__p_int,
45740 _swigt__p_wxSize,
45741 _swigt__p_wxDC,
45742 _swigt__p_wxPySizer,
45743 _swigt__p_wxVisualAttributes,
45744 _swigt__p_wxNotifyEvent,
45745 _swigt__p_wxPyEvent,
45746 _swigt__p_wxPropagationDisabler,
45747 _swigt__p_form_ops_t,
45748 _swigt__p_wxAppTraits,
45749 _swigt__p_wxArrayString,
45750 _swigt__p_wxShowEvent,
45751 _swigt__p_wxToolTip,
45752 _swigt__p_wxMoveEvent,
45753 _swigt__p_wxSizeEvent,
45754 _swigt__p_wxActivateEvent,
45755 _swigt__p_wxIconizeEvent,
45756 _swigt__p_wxMaximizeEvent,
45757 _swigt__p_wxQueryNewPaletteEvent,
45758 _swigt__p_wxWindowCreateEvent,
45759 _swigt__p_wxIdleEvent,
45760 _swigt__p_wxMenuItem,
45761 _swigt__p_wxStaticBox,
45762 _swigt__p_long,
45763 _swigt__p_wxDuplexMode,
45764 _swigt__p_wxTIFFHandler,
45765 _swigt__p_wxXPMHandler,
45766 _swigt__p_wxPNMHandler,
45767 _swigt__p_wxJPEGHandler,
45768 _swigt__p_wxPCXHandler,
45769 _swigt__p_wxGIFHandler,
45770 _swigt__p_wxPNGHandler,
45771 _swigt__p_wxANIHandler,
45772 _swigt__p_wxMemoryFSHandler,
45773 _swigt__p_wxZipFSHandler,
45774 _swigt__p_wxInternetFSHandler,
45775 _swigt__p_wxPyFileSystemHandler,
45776 _swigt__p_wxEvtHandler,
45777 _swigt__p_wxCURHandler,
45778 _swigt__p_wxICOHandler,
45779 _swigt__p_wxBMPHandler,
45780 _swigt__p_wxImageHandler,
45781 _swigt__p_wxFileSystemHandler,
45782 _swigt__p_wxRect,
45783 _swigt__p_wxButton,
45784 _swigt__p_wxGBSpan,
45785 _swigt__p_wxPropagateOnce,
45786 _swigt__p_wxAcceleratorTable,
45787 _swigt__p_wxStdDialogButtonSizer,
45788 _swigt__p_char,
45789 _swigt__p_wxGBPosition,
45790 _swigt__p_wxImage,
45791 _swigt__p_wxFrame,
45792 _swigt__p_wxScrollWinEvent,
45793 _swigt__p_wxPaperSize,
45794 _swigt__p_wxImageHistogram,
45795 _swigt__p_wxPoint,
45796 _swigt__p_wxCursor,
45797 _swigt__p_wxObject,
45798 _swigt__p_wxInputStream,
45799 _swigt__p_wxOutputStream,
45800 _swigt__p_wxPyInputStream,
45801 _swigt__p_wxDateTime,
45802 _swigt__p_wxKeyEvent,
45803 _swigt__p_wxNavigationKeyEvent,
45804 _swigt__p_wxWindowDestroyEvent,
45805 _swigt__p_unsigned_long,
45806 _swigt__p_wxWindow,
45807 _swigt__p_wxMenuBar,
45808 _swigt__p_wxFileSystem,
45809 _swigt__p_wxBitmap,
45810 _swigt__unsigned_int,
45811 _swigt__p_unsigned_int,
45812 _swigt__p_wxMenuEvent,
45813 _swigt__p_wxContextMenuEvent,
45814 _swigt__p_unsigned_char,
45815 _swigt__p_wxEraseEvent,
45816 _swigt__p_wxMouseEvent,
45817 _swigt__p_wxCloseEvent,
45818 _swigt__p_wxPyApp,
45819 _swigt__p_wxCommandEvent,
45820 _swigt__p_wxPyCommandEvent,
45821 _swigt__p_wxPyDropTarget,
45822 _swigt__p_wxQuantize,
45823 _swigt__p_wxChildFocusEvent,
45824 _swigt__p_wxFocusEvent,
45825 _swigt__p_wxDropFilesEvent,
45826 _swigt__p_wxControlWithItems,
45827 _swigt__p_wxColour,
45828 _swigt__p_wxValidator,
45829 _swigt__p_wxPyValidator,
45830 0
45831 };
45832
45833
45834 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
45835
45836 static swig_const_info swig_const_table[] = {
45837 {0, 0, 0, 0.0, 0, 0}};
45838
45839 #ifdef __cplusplus
45840 }
45841 #endif
45842
45843
45844 #ifdef __cplusplus
45845 extern "C" {
45846 #endif
45847
45848 /* Python-specific SWIG API */
45849 #define SWIG_newvarlink() SWIG_Python_newvarlink()
45850 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
45851 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
45852
45853 /* -----------------------------------------------------------------------------
45854 * global variable support code.
45855 * ----------------------------------------------------------------------------- */
45856
45857 typedef struct swig_globalvar {
45858 char *name; /* Name of global variable */
45859 PyObject *(*get_attr)(); /* Return the current value */
45860 int (*set_attr)(PyObject *); /* Set the value */
45861 struct swig_globalvar *next;
45862 } swig_globalvar;
45863
45864 typedef struct swig_varlinkobject {
45865 PyObject_HEAD
45866 swig_globalvar *vars;
45867 } swig_varlinkobject;
45868
45869 static PyObject *
45870 swig_varlink_repr(swig_varlinkobject *v) {
45871 v = v;
45872 return PyString_FromString("<Swig global variables>");
45873 }
45874
45875 static int
45876 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
45877 swig_globalvar *var;
45878 flags = flags;
45879 fprintf(fp,"Swig global variables { ");
45880 for (var = v->vars; var; var=var->next) {
45881 fprintf(fp,"%s", var->name);
45882 if (var->next) fprintf(fp,", ");
45883 }
45884 fprintf(fp," }\n");
45885 return 0;
45886 }
45887
45888 static PyObject *
45889 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
45890 swig_globalvar *var = v->vars;
45891 while (var) {
45892 if (strcmp(var->name,n) == 0) {
45893 return (*var->get_attr)();
45894 }
45895 var = var->next;
45896 }
45897 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45898 return NULL;
45899 }
45900
45901 static int
45902 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
45903 swig_globalvar *var = v->vars;
45904 while (var) {
45905 if (strcmp(var->name,n) == 0) {
45906 return (*var->set_attr)(p);
45907 }
45908 var = var->next;
45909 }
45910 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45911 return 1;
45912 }
45913
45914 static PyTypeObject varlinktype = {
45915 PyObject_HEAD_INIT(0)
45916 0, /* Number of items in variable part (ob_size) */
45917 (char *)"swigvarlink", /* Type name (tp_name) */
45918 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
45919 0, /* Itemsize (tp_itemsize) */
45920 0, /* Deallocator (tp_dealloc) */
45921 (printfunc) swig_varlink_print, /* Print (tp_print) */
45922 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
45923 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
45924 0, /* tp_compare */
45925 (reprfunc) swig_varlink_repr, /* tp_repr */
45926 0, /* tp_as_number */
45927 0, /* tp_as_sequence */
45928 0, /* tp_as_mapping */
45929 0, /* tp_hash */
45930 0, /* tp_call */
45931 0, /* tp_str */
45932 0, /* tp_getattro */
45933 0, /* tp_setattro */
45934 0, /* tp_as_buffer */
45935 0, /* tp_flags */
45936 0, /* tp_doc */
45937 #if PY_VERSION_HEX >= 0x02000000
45938 0, /* tp_traverse */
45939 0, /* tp_clear */
45940 #endif
45941 #if PY_VERSION_HEX >= 0x02010000
45942 0, /* tp_richcompare */
45943 0, /* tp_weaklistoffset */
45944 #endif
45945 #if PY_VERSION_HEX >= 0x02020000
45946 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
45947 #endif
45948 #if PY_VERSION_HEX >= 0x02030000
45949 0, /* tp_del */
45950 #endif
45951 #ifdef COUNT_ALLOCS
45952 0,0,0,0 /* tp_alloc -> tp_next */
45953 #endif
45954 };
45955
45956 /* Create a variable linking object for use later */
45957 static PyObject *
45958 SWIG_Python_newvarlink(void) {
45959 swig_varlinkobject *result = 0;
45960 result = PyMem_NEW(swig_varlinkobject,1);
45961 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
45962 result->ob_type = &varlinktype;
45963 result->vars = 0;
45964 result->ob_refcnt = 0;
45965 Py_XINCREF((PyObject *) result);
45966 return ((PyObject*) result);
45967 }
45968
45969 static void
45970 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
45971 swig_varlinkobject *v;
45972 swig_globalvar *gv;
45973 v= (swig_varlinkobject *) p;
45974 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
45975 gv->name = (char *) malloc(strlen(name)+1);
45976 strcpy(gv->name,name);
45977 gv->get_attr = get_attr;
45978 gv->set_attr = set_attr;
45979 gv->next = v->vars;
45980 v->vars = gv;
45981 }
45982
45983 /* -----------------------------------------------------------------------------
45984 * constants/methods manipulation
45985 * ----------------------------------------------------------------------------- */
45986
45987 /* Install Constants */
45988 static void
45989 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
45990 PyObject *obj = 0;
45991 size_t i;
45992 for (i = 0; constants[i].type; i++) {
45993 switch(constants[i].type) {
45994 case SWIG_PY_INT:
45995 obj = PyInt_FromLong(constants[i].lvalue);
45996 break;
45997 case SWIG_PY_FLOAT:
45998 obj = PyFloat_FromDouble(constants[i].dvalue);
45999 break;
46000 case SWIG_PY_STRING:
46001 if (constants[i].pvalue) {
46002 obj = PyString_FromString((char *) constants[i].pvalue);
46003 } else {
46004 Py_INCREF(Py_None);
46005 obj = Py_None;
46006 }
46007 break;
46008 case SWIG_PY_POINTER:
46009 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46010 break;
46011 case SWIG_PY_BINARY:
46012 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46013 break;
46014 default:
46015 obj = 0;
46016 break;
46017 }
46018 if (obj) {
46019 PyDict_SetItemString(d,constants[i].name,obj);
46020 Py_DECREF(obj);
46021 }
46022 }
46023 }
46024
46025 /* -----------------------------------------------------------------------------*/
46026 /* Fix SwigMethods to carry the callback ptrs when needed */
46027 /* -----------------------------------------------------------------------------*/
46028
46029 static void
46030 SWIG_Python_FixMethods(PyMethodDef *methods,
46031 swig_const_info *const_table,
46032 swig_type_info **types,
46033 swig_type_info **types_initial) {
46034 size_t i;
46035 for (i = 0; methods[i].ml_name; ++i) {
46036 char *c = methods[i].ml_doc;
46037 if (c && (c = strstr(c, "swig_ptr: "))) {
46038 int j;
46039 swig_const_info *ci = 0;
46040 char *name = c + 10;
46041 for (j = 0; const_table[j].type; j++) {
46042 if (strncmp(const_table[j].name, name,
46043 strlen(const_table[j].name)) == 0) {
46044 ci = &(const_table[j]);
46045 break;
46046 }
46047 }
46048 if (ci) {
46049 size_t shift = (ci->ptype) - types;
46050 swig_type_info *ty = types_initial[shift];
46051 size_t ldoc = (c - methods[i].ml_doc);
46052 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46053 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46054 char *buff = ndoc;
46055 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46056 strncpy(buff, methods[i].ml_doc, ldoc);
46057 buff += ldoc;
46058 strncpy(buff, "swig_ptr: ", 10);
46059 buff += 10;
46060 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46061 methods[i].ml_doc = ndoc;
46062 }
46063 }
46064 }
46065 }
46066
46067 /* -----------------------------------------------------------------------------*
46068 * Initialize type list
46069 * -----------------------------------------------------------------------------*/
46070
46071 #if PY_MAJOR_VERSION < 2
46072 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46073 is copied out of Python/modsupport.c in python version 2.3.4 */
46074 static int
46075 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46076 {
46077 PyObject *dict;
46078 if (!PyModule_Check(m)) {
46079 PyErr_SetString(PyExc_TypeError,
46080 "PyModule_AddObject() needs module as first arg");
46081 return -1;
46082 }
46083 if (!o) {
46084 PyErr_SetString(PyExc_TypeError,
46085 "PyModule_AddObject() needs non-NULL value");
46086 return -1;
46087 }
46088
46089 dict = PyModule_GetDict(m);
46090 if (dict == NULL) {
46091 /* Internal error -- modules must have a dict! */
46092 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46093 PyModule_GetName(m));
46094 return -1;
46095 }
46096 if (PyDict_SetItemString(dict, name, o))
46097 return -1;
46098 Py_DECREF(o);
46099 return 0;
46100 }
46101 #endif
46102
46103 static swig_type_info **
46104 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46105 static PyMethodDef swig_empty_runtime_method_table[] = {
46106 {
46107 NULL, NULL, 0, NULL
46108 }
46109 };/* Sentinel */
46110
46111 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46112 swig_empty_runtime_method_table);
46113 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46114 if (pointer && module) {
46115 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46116 }
46117 return type_list_handle;
46118 }
46119
46120 static swig_type_info **
46121 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46122 swig_type_info **type_pointer;
46123
46124 /* first check if module already created */
46125 type_pointer = SWIG_Python_GetTypeListHandle();
46126 if (type_pointer) {
46127 return type_pointer;
46128 } else {
46129 /* create a new module and variable */
46130 return SWIG_Python_SetTypeListHandle(type_list_handle);
46131 }
46132 }
46133
46134 #ifdef __cplusplus
46135 }
46136 #endif
46137
46138 /* -----------------------------------------------------------------------------*
46139 * Partial Init method
46140 * -----------------------------------------------------------------------------*/
46141
46142 #ifdef SWIG_LINK_RUNTIME
46143 #ifdef __cplusplus
46144 extern "C"
46145 #endif
46146 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46147 #endif
46148
46149 #ifdef __cplusplus
46150 extern "C"
46151 #endif
46152 SWIGEXPORT(void) SWIG_init(void) {
46153 static PyObject *SWIG_globals = 0;
46154 static int typeinit = 0;
46155 PyObject *m, *d;
46156 int i;
46157 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46158
46159 /* Fix SwigMethods to carry the callback ptrs when needed */
46160 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46161
46162 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46163 d = PyModule_GetDict(m);
46164
46165 if (!typeinit) {
46166 #ifdef SWIG_LINK_RUNTIME
46167 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46168 #else
46169 # ifndef SWIG_STATIC_RUNTIME
46170 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46171 # endif
46172 #endif
46173 for (i = 0; swig_types_initial[i]; i++) {
46174 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46175 }
46176 typeinit = 1;
46177 }
46178 SWIG_InstallConstants(d,swig_const_table);
46179
46180
46181 #ifndef wxPyUSE_EXPORT
46182 // Make our API structure a CObject so other modules can import it
46183 // from this module.
46184 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46185 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46186 Py_XDECREF(cobj);
46187 #endif
46188
46189 {
46190 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46191 }
46192 {
46193 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46194 }
46195 {
46196 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46197 }
46198 {
46199 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46200 }
46201 {
46202 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46203 }
46204 {
46205 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46206 }
46207 {
46208 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46209 }
46210 {
46211 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46212 }
46213 {
46214 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46215 }
46216 {
46217 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46218 }
46219 {
46220 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46221 }
46222 {
46223 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46224 }
46225 {
46226 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46227 }
46228 {
46229 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46230 }
46231 {
46232 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46233 }
46234 {
46235 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46236 }
46237 {
46238 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46239 }
46240 {
46241 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46242 }
46243 {
46244 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46245 }
46246 {
46247 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46248 }
46249 {
46250 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46251 }
46252 {
46253 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46254 }
46255 {
46256 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46257 }
46258 {
46259 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46260 }
46261 {
46262 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46263 }
46264 {
46265 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46266 }
46267 {
46268 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46269 }
46270 {
46271 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46272 }
46273 {
46274 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46275 }
46276 {
46277 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46278 }
46279 {
46280 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46281 }
46282 {
46283 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46284 }
46285 {
46286 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46287 }
46288 {
46289 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46290 }
46291 {
46292 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46293 }
46294 {
46295 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46296 }
46297 {
46298 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46299 }
46300 {
46301 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46302 }
46303 {
46304 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46305 }
46306 {
46307 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46308 }
46309 {
46310 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46311 }
46312 {
46313 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46314 }
46315 {
46316 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46317 }
46318 {
46319 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46320 }
46321 {
46322 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46323 }
46324 {
46325 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46326 }
46327 {
46328 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46329 }
46330 {
46331 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46332 }
46333 {
46334 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46335 }
46336 {
46337 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46338 }
46339 {
46340 PyDict_SetItemString(d,"SL_HORIZONTAL", SWIG_From_int((int)(wxSL_HORIZONTAL)));
46341 }
46342 {
46343 PyDict_SetItemString(d,"SL_VERTICAL", SWIG_From_int((int)(wxSL_VERTICAL)));
46344 }
46345 {
46346 PyDict_SetItemString(d,"SL_AUTOTICKS", SWIG_From_int((int)(wxSL_AUTOTICKS)));
46347 }
46348 {
46349 PyDict_SetItemString(d,"SL_LABELS", SWIG_From_int((int)(wxSL_LABELS)));
46350 }
46351 {
46352 PyDict_SetItemString(d,"SL_LEFT", SWIG_From_int((int)(wxSL_LEFT)));
46353 }
46354 {
46355 PyDict_SetItemString(d,"SL_TOP", SWIG_From_int((int)(wxSL_TOP)));
46356 }
46357 {
46358 PyDict_SetItemString(d,"SL_RIGHT", SWIG_From_int((int)(wxSL_RIGHT)));
46359 }
46360 {
46361 PyDict_SetItemString(d,"SL_BOTTOM", SWIG_From_int((int)(wxSL_BOTTOM)));
46362 }
46363 {
46364 PyDict_SetItemString(d,"SL_BOTH", SWIG_From_int((int)(wxSL_BOTH)));
46365 }
46366 {
46367 PyDict_SetItemString(d,"SL_SELRANGE", SWIG_From_int((int)(wxSL_SELRANGE)));
46368 }
46369 {
46370 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46371 }
46372 {
46373 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46374 }
46375 {
46376 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46377 }
46378 {
46379 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46380 }
46381 {
46382 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46383 }
46384 {
46385 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46386 }
46387 {
46388 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46389 }
46390 {
46391 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46392 }
46393 {
46394 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46395 }
46396 {
46397 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46398 }
46399 {
46400 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46401 }
46402 {
46403 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46404 }
46405 {
46406 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46407 }
46408 {
46409 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46410 }
46411 {
46412 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46413 }
46414 {
46415 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46416 }
46417 {
46418 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46419 }
46420 {
46421 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46422 }
46423 {
46424 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46425 }
46426 {
46427 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46428 }
46429 {
46430 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46431 }
46432 {
46433 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46434 }
46435 {
46436 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46437 }
46438 {
46439 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46440 }
46441 {
46442 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46443 }
46444 {
46445 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46446 }
46447 {
46448 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46449 }
46450 {
46451 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46452 }
46453 {
46454 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46455 }
46456 {
46457 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46458 }
46459 {
46460 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46461 }
46462 {
46463 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46464 }
46465 {
46466 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46467 }
46468 {
46469 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46470 }
46471 {
46472 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46473 }
46474 {
46475 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46476 }
46477 {
46478 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46479 }
46480 {
46481 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46482 }
46483 {
46484 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46485 }
46486 {
46487 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46488 }
46489 {
46490 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46491 }
46492 {
46493 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46494 }
46495 {
46496 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46497 }
46498 {
46499 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46500 }
46501 {
46502 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46503 }
46504 {
46505 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46506 }
46507 {
46508 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46509 }
46510 {
46511 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46512 }
46513 {
46514 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46515 }
46516 {
46517 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46518 }
46519 {
46520 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46521 }
46522 {
46523 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46524 }
46525 {
46526 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46527 }
46528 {
46529 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46530 }
46531 {
46532 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46533 }
46534 {
46535 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46536 }
46537 {
46538 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46539 }
46540 {
46541 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46542 }
46543 {
46544 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46545 }
46546 {
46547 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46548 }
46549 {
46550 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46551 }
46552 {
46553 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46554 }
46555 {
46556 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46557 }
46558 {
46559 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46560 }
46561 {
46562 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46563 }
46564 {
46565 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46566 }
46567 {
46568 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46569 }
46570 {
46571 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46572 }
46573 {
46574 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46575 }
46576 {
46577 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46578 }
46579 {
46580 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46581 }
46582 {
46583 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46584 }
46585 {
46586 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46587 }
46588 {
46589 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46590 }
46591 {
46592 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46593 }
46594 {
46595 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46596 }
46597 {
46598 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46599 }
46600 {
46601 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46602 }
46603 {
46604 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46605 }
46606 {
46607 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46608 }
46609 {
46610 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46611 }
46612 {
46613 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46614 }
46615 {
46616 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46617 }
46618 {
46619 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46620 }
46621 {
46622 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46623 }
46624 {
46625 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46626 }
46627 {
46628 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46629 }
46630 {
46631 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46632 }
46633 {
46634 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46635 }
46636 {
46637 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46638 }
46639 {
46640 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46641 }
46642 {
46643 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46644 }
46645 {
46646 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46647 }
46648 {
46649 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46650 }
46651 {
46652 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46653 }
46654 {
46655 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46656 }
46657 {
46658 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46659 }
46660 {
46661 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46662 }
46663 {
46664 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46665 }
46666 {
46667 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46668 }
46669 {
46670 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46671 }
46672 {
46673 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46674 }
46675 {
46676 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46677 }
46678 {
46679 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46680 }
46681 {
46682 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46683 }
46684 {
46685 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46686 }
46687 {
46688 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46689 }
46690 {
46691 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46692 }
46693 {
46694 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46695 }
46696 {
46697 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46698 }
46699 {
46700 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46701 }
46702 {
46703 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46704 }
46705 {
46706 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46707 }
46708 {
46709 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46710 }
46711 {
46712 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46713 }
46714 {
46715 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46716 }
46717 {
46718 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46719 }
46720 {
46721 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46722 }
46723 {
46724 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46725 }
46726 {
46727 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46728 }
46729 {
46730 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46731 }
46732 {
46733 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46734 }
46735 {
46736 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46737 }
46738 {
46739 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46740 }
46741 {
46742 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46743 }
46744 {
46745 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46746 }
46747 {
46748 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46749 }
46750 {
46751 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46752 }
46753 {
46754 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46755 }
46756 {
46757 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46758 }
46759 {
46760 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46761 }
46762 {
46763 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46764 }
46765 {
46766 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46767 }
46768 {
46769 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46770 }
46771 {
46772 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46773 }
46774 {
46775 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46776 }
46777 {
46778 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46779 }
46780 {
46781 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46782 }
46783 {
46784 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46785 }
46786 {
46787 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46788 }
46789 {
46790 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46791 }
46792 {
46793 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
46794 }
46795 {
46796 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
46797 }
46798 {
46799 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
46800 }
46801 {
46802 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
46803 }
46804 {
46805 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
46806 }
46807 {
46808 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
46809 }
46810 {
46811 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
46812 }
46813 {
46814 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
46815 }
46816 {
46817 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
46818 }
46819 {
46820 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
46821 }
46822 {
46823 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
46824 }
46825 {
46826 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
46827 }
46828 {
46829 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
46830 }
46831 {
46832 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
46833 }
46834 {
46835 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
46836 }
46837 {
46838 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
47817 }
47818 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
47819 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
47820 {
47821 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
47972 }
47973 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
47974 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
47975 {
47976 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
47983 }
47984
47985 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
47986
47987
47988 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
47989
47990 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
47991 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
47992 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
47993 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
47994 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
47995 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
47996 {
47997 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48040 }
48041 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48042 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48043 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48044 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48045 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48046 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48047 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48048 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48049 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48050 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48051 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48052 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48053 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48054 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48055 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48056 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48057 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48058 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48059 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48060 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48061 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48062 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48063 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48064 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48065 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48066 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48067 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48068 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48069 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48070 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48071 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48072 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48073 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48074 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48075 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48076 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48077 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48078 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48079 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48080 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48081 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48082 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48083 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48084 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48085 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48086 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48087 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48088 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48089 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48090 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48091 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48092 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48093 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48094 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48095 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48096 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48097 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48098 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48099 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48100 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48101 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48102 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48103 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48104 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48105 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48106 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48107 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48108 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48109 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48110 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48111 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48112 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48113 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48114 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48115 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48116 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48117 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48118 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48119 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48120 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48121 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48122 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48123 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48124 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48125 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48126 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48127 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48128 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48129 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48130 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48131 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48132 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48133 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48134 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48135 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48136 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48137 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48138 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48139 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48140 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48141 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48142 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48143 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48144 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48145 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48146 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48147 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48148 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48149 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48150 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48151 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48152 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48153 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48154 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48155 {
48156 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48208 }
48209 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48210 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48211 {
48212 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48225 }
48226 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48227 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48228 {
48229 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48236 }
48237 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48238 {
48239 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48294 }
48295
48296 // Initialize threading, some globals and such
48297 __wxPyPreStart(d);
48298
48299
48300 // Although these are defined in __version__ they need to be here too so
48301 // that an assert can be done to ensure that the wxPython and the wxWindows
48302 // versions match.
48303 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48304 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48305 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48306
48307 }
48308
wxWidgets (Impactor)