]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied patch [ 1312729 ] fix for wxMac Carbon spin control on EVT_TEXT emitter
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxNcPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_wxImage_HSVValue swig_types[36]
1379 #define SWIGTYPE_p_int swig_types[37]
1380 #define SWIGTYPE_p_wxSize swig_types[38]
1381 #define SWIGTYPE_p_wxDC swig_types[39]
1382 #define SWIGTYPE_p_wxPySizer swig_types[40]
1383 #define SWIGTYPE_p_wxVisualAttributes swig_types[41]
1384 #define SWIGTYPE_p_wxImage_RGBValue swig_types[42]
1385 #define SWIGTYPE_p_wxNotifyEvent swig_types[43]
1386 #define SWIGTYPE_p_wxPyEvent swig_types[44]
1387 #define SWIGTYPE_p_wxPropagationDisabler swig_types[45]
1388 #define SWIGTYPE_p_form_ops_t swig_types[46]
1389 #define SWIGTYPE_p_wxAppTraits swig_types[47]
1390 #define SWIGTYPE_p_wxArrayString swig_types[48]
1391 #define SWIGTYPE_p_wxShowEvent swig_types[49]
1392 #define SWIGTYPE_p_wxToolTip swig_types[50]
1393 #define SWIGTYPE_p_wxMoveEvent swig_types[51]
1394 #define SWIGTYPE_p_wxSizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxActivateEvent swig_types[53]
1396 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
1397 #define SWIGTYPE_p_wxMaximizeEvent swig_types[55]
1398 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[56]
1399 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
1401 #define SWIGTYPE_p_wxDateEvent swig_types[59]
1402 #define SWIGTYPE_p_wxMenuItem swig_types[60]
1403 #define SWIGTYPE_p_wxStaticBox swig_types[61]
1404 #define SWIGTYPE_p_long swig_types[62]
1405 #define SWIGTYPE_p_wxDuplexMode swig_types[63]
1406 #define SWIGTYPE_p_wxTIFFHandler swig_types[64]
1407 #define SWIGTYPE_p_wxXPMHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPNMHandler swig_types[66]
1409 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPCXHandler swig_types[68]
1411 #define SWIGTYPE_p_wxGIFHandler swig_types[69]
1412 #define SWIGTYPE_p_wxPNGHandler swig_types[70]
1413 #define SWIGTYPE_p_wxANIHandler swig_types[71]
1414 #define SWIGTYPE_p_wxPyImageHandler swig_types[72]
1415 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
1416 #define SWIGTYPE_p_wxZipFSHandler swig_types[74]
1417 #define SWIGTYPE_p_wxInternetFSHandler swig_types[75]
1418 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[76]
1419 #define SWIGTYPE_p_wxEvtHandler swig_types[77]
1420 #define SWIGTYPE_p_wxCURHandler swig_types[78]
1421 #define SWIGTYPE_p_wxICOHandler swig_types[79]
1422 #define SWIGTYPE_p_wxBMPHandler swig_types[80]
1423 #define SWIGTYPE_p_wxImageHandler swig_types[81]
1424 #define SWIGTYPE_p_wxFileSystemHandler swig_types[82]
1425 #define SWIGTYPE_p_wxRect swig_types[83]
1426 #define SWIGTYPE_p_wxButton swig_types[84]
1427 #define SWIGTYPE_p_wxGBSpan swig_types[85]
1428 #define SWIGTYPE_p_wxPropagateOnce swig_types[86]
1429 #define SWIGTYPE_p_wxAcceleratorTable swig_types[87]
1430 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[88]
1431 #define SWIGTYPE_p_char swig_types[89]
1432 #define SWIGTYPE_p_wxGBPosition swig_types[90]
1433 #define SWIGTYPE_p_wxImage swig_types[91]
1434 #define SWIGTYPE_p_wxFrame swig_types[92]
1435 #define SWIGTYPE_p_wxScrollWinEvent swig_types[93]
1436 #define SWIGTYPE_p_wxPaperSize swig_types[94]
1437 #define SWIGTYPE_p_wxImageHistogram swig_types[95]
1438 #define SWIGTYPE_p_wxPoint swig_types[96]
1439 #define SWIGTYPE_p_wxCursor swig_types[97]
1440 #define SWIGTYPE_p_wxObject swig_types[98]
1441 #define SWIGTYPE_p_wxInputStream swig_types[99]
1442 #define SWIGTYPE_p_wxOutputStream swig_types[100]
1443 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
1444 #define SWIGTYPE_p_wxDateTime swig_types[102]
1445 #define SWIGTYPE_p_wxKeyEvent swig_types[103]
1446 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
1447 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[105]
1448 #define SWIGTYPE_p_unsigned_long swig_types[106]
1449 #define SWIGTYPE_p_wxWindow swig_types[107]
1450 #define SWIGTYPE_p_wxMenuBar swig_types[108]
1451 #define SWIGTYPE_p_wxFileSystem swig_types[109]
1452 #define SWIGTYPE_p_wxBitmap swig_types[110]
1453 #define SWIGTYPE_unsigned_int swig_types[111]
1454 #define SWIGTYPE_p_unsigned_int swig_types[112]
1455 #define SWIGTYPE_p_wxMenuEvent swig_types[113]
1456 #define SWIGTYPE_p_wxContextMenuEvent swig_types[114]
1457 #define SWIGTYPE_p_unsigned_char swig_types[115]
1458 #define SWIGTYPE_p_wxMouseEvent swig_types[116]
1459 #define SWIGTYPE_p_wxEraseEvent swig_types[117]
1460 #define SWIGTYPE_p_wxCloseEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyApp swig_types[119]
1462 #define SWIGTYPE_p_wxCommandEvent swig_types[120]
1463 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
1464 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
1465 #define SWIGTYPE_p_wxQuantize swig_types[123]
1466 #define SWIGTYPE_p_wxFocusEvent swig_types[124]
1467 #define SWIGTYPE_p_wxChildFocusEvent swig_types[125]
1468 #define SWIGTYPE_p_wxDropFilesEvent swig_types[126]
1469 #define SWIGTYPE_p_wxControlWithItems swig_types[127]
1470 #define SWIGTYPE_p_wxColour swig_types[128]
1471 #define SWIGTYPE_p_wxValidator swig_types[129]
1472 #define SWIGTYPE_p_wxPyValidator swig_types[130]
1473 static swig_type_info *swig_types[132];
1474
1475 /* -------- TYPES TABLE (END) -------- */
1476
1477
1478 /*-----------------------------------------------
1479 @(target):= _core_.so
1480 ------------------------------------------------*/
1481 #define SWIG_init init_core_
1482
1483 #define SWIG_name "_core_"
1484
1485 #include "wx/wxPython/wxPython_int.h"
1486 #include "wx/wxPython/pyclasses.h"
1487
1488
1489 #ifndef wxPyUSE_EXPORT
1490 // Helper functions for dealing with SWIG objects and such. These are
1491 // located here so they know about the SWIG types and functions declared
1492 // in the wrapper code.
1493
1494 #include <wx/hashmap.h>
1495 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1496
1497
1498 // Maintains a hashmap of className to swig_type_info pointers. Given the
1499 // name of a class either looks up the type info in the cache, or scans the
1500 // SWIG tables for it.
1501 extern PyObject* wxPyPtrTypeMap;
1502 static
1503 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1504
1505 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1506
1507 if (typeInfoCache == NULL)
1508 typeInfoCache = new wxPyTypeInfoHashMap;
1509
1510 wxString name(className);
1511 swig_type_info* swigType = (*typeInfoCache)[name];
1512
1513 if (! swigType) {
1514 // it wasn't in the cache, so look it up from SWIG
1515 name.Append(wxT(" *"));
1516 swigType = SWIG_TypeQuery(name.mb_str());
1517
1518 // if it still wasn't found, try looking for a mapped name
1519 if (!swigType) {
1520 PyObject* item;
1521 name = className;
1522
1523 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1524 (char*)(const char*)name.mbc_str())) != NULL) {
1525 name = wxString(PyString_AsString(item), *wxConvCurrent);
1526 name.Append(wxT(" *"));
1527 swigType = SWIG_TypeQuery(name.mb_str());
1528 }
1529 }
1530 if (swigType) {
1531 // and add it to the map if found
1532 (*typeInfoCache)[className] = swigType;
1533 }
1534 }
1535 return swigType;
1536 }
1537
1538
1539 // Check if a class name is a type known to SWIG
1540 bool wxPyCheckSwigType(const wxChar* className) {
1541
1542 swig_type_info* swigType = wxPyFindSwigType(className);
1543 return swigType != NULL;
1544 }
1545
1546
1547 // Given a pointer to a C++ object and a class name, construct a Python proxy
1548 // object for it.
1549 PyObject* wxPyConstructObject(void* ptr,
1550 const wxChar* className,
1551 int setThisOwn) {
1552
1553 swig_type_info* swigType = wxPyFindSwigType(className);
1554 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1555
1556 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1557 }
1558
1559
1560 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1561 // Ensures that the proxy object is of the specified (or derived) type. If
1562 // not able to perform the conversion then a Python exception is set and the
1563 // error should be handled properly in the caller. Returns True on success.
1564 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1565 const wxChar* className) {
1566
1567 swig_type_info* swigType = wxPyFindSwigType(className);
1568 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1569
1570 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1571 }
1572
1573
1574 // Make a SWIGified pointer object suitable for a .this attribute
1575 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1576
1577 PyObject* robj = NULL;
1578
1579 swig_type_info* swigType = wxPyFindSwigType(className);
1580 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1581
1582 #ifdef SWIG_COBJECT_TYPES
1583 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1584 #else
1585 {
1586 char result[1024];
1587 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1588 PyString_FromString(result) : 0;
1589 }
1590 #endif
1591
1592 return robj;
1593 }
1594
1595
1596 // Python's PyInstance_Check does not return True for instances of new-style
1597 // classes. This should get close enough for both new and old classes but I
1598 // should re-evaluate the need for doing instance checks...
1599 bool wxPyInstance_Check(PyObject* obj) {
1600 return PyObject_HasAttrString(obj, "__class__") != 0;
1601 }
1602
1603
1604
1605 // This one checks if the object is an instance of a SWIG proxy class (it has
1606 // a .this attribute, and the .this attribute is a PySwigObject.)
1607 bool wxPySwigInstance_Check(PyObject* obj) {
1608 static PyObject* this_str = NULL;
1609 if (this_str == NULL)
1610 this_str = PyString_FromString("this");
1611
1612 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1613 if (this_attr) {
1614 bool retval = (PySwigObject_Check(this_attr) != 0);
1615 Py_DECREF(this_attr);
1616 return retval;
1617 }
1618
1619 PyErr_Clear();
1620 return false;
1621 }
1622
1623
1624
1625 // Export a C API in a struct. Other modules will be able to load this from
1626 // the wx._core_ module and will then have safe access to these functions,
1627 // even if they are located in another shared library.
1628 static wxPyCoreAPI API = {
1629
1630 wxPyCheckSwigType,
1631 wxPyConstructObject,
1632 wxPyConvertSwigPtr,
1633 wxPyMakeSwigPtr,
1634
1635 wxPyBeginAllowThreads,
1636 wxPyEndAllowThreads,
1637 wxPyBeginBlockThreads,
1638 wxPyEndBlockThreads,
1639
1640 wxPy_ConvertList,
1641
1642 wxString_in_helper,
1643 Py2wxString,
1644 wx2PyString,
1645
1646 byte_LIST_helper,
1647 int_LIST_helper,
1648 long_LIST_helper,
1649 string_LIST_helper,
1650 wxPoint_LIST_helper,
1651 wxBitmap_LIST_helper,
1652 wxString_LIST_helper,
1653 wxAcceleratorEntry_LIST_helper,
1654
1655 wxSize_helper,
1656 wxPoint_helper,
1657 wxRealPoint_helper,
1658 wxRect_helper,
1659 wxColour_helper,
1660 wxPoint2D_helper,
1661
1662 wxPySimple_typecheck,
1663 wxColour_typecheck,
1664
1665 wxPyCBH_setCallbackInfo,
1666 wxPyCBH_findCallback,
1667 wxPyCBH_callCallback,
1668 wxPyCBH_callCallbackObj,
1669 wxPyCBH_delete,
1670
1671 wxPyMake_wxObject,
1672 wxPyMake_wxSizer,
1673 wxPyPtrTypeMap_Add,
1674 wxPy2int_seq_helper,
1675 wxPy4int_seq_helper,
1676 wxArrayString2PyList_helper,
1677 wxArrayInt2PyList_helper,
1678
1679 wxPyClientData_dtor,
1680 wxPyUserData_dtor,
1681 wxPyOORClientData_dtor,
1682
1683 wxPyCBInputStream_create,
1684 wxPyCBInputStream_copy,
1685
1686 wxPyInstance_Check,
1687 wxPySwigInstance_Check,
1688
1689 wxPyCheckForApp
1690
1691 };
1692
1693 #endif
1694
1695
1696 #if !WXWIN_COMPATIBILITY_2_4
1697 #define wxHIDE_READONLY 0
1698 #endif
1699
1700
1701 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1702 #define SWIG_From_int PyInt_FromLong
1703 /*@@*/
1704
1705 static const wxString wxPyEmptyString(wxEmptyString);
1706 static wxString wxObject_GetClassName(wxObject *self){
1707 return self->GetClassInfo()->GetClassName();
1708 }
1709 static void wxObject_Destroy(wxObject *self){
1710 delete self;
1711 }
1712
1713 #ifndef __WXMAC__
1714 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1715 #endif
1716
1717
1718 #include <limits.h>
1719
1720
1721 SWIGINTERN int
1722 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1723 const char *errmsg)
1724 {
1725 if (value < min_value) {
1726 if (errmsg) {
1727 PyErr_Format(PyExc_OverflowError,
1728 "value %ld is less than '%s' minimum %ld",
1729 value, errmsg, min_value);
1730 }
1731 return 0;
1732 } else if (value > max_value) {
1733 if (errmsg) {
1734 PyErr_Format(PyExc_OverflowError,
1735 "value %ld is greater than '%s' maximum %ld",
1736 value, errmsg, max_value);
1737 }
1738 return 0;
1739 }
1740 return 1;
1741 }
1742
1743
1744 SWIGINTERN int
1745 SWIG_AsVal_long(PyObject* obj, long* val)
1746 {
1747 if (PyNumber_Check(obj)) {
1748 if (val) *val = PyInt_AsLong(obj);
1749 return 1;
1750 }
1751 else {
1752 SWIG_type_error("number", obj);
1753 }
1754 return 0;
1755 }
1756
1757
1758 #if INT_MAX != LONG_MAX
1759 SWIGINTERN int
1760 SWIG_AsVal_int(PyObject *obj, int *val)
1761 {
1762 const char* errmsg = val ? "int" : (char*)0;
1763 long v;
1764 if (SWIG_AsVal_long(obj, &v)) {
1765 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1766 if (val) *val = (int)(v);
1767 return 1;
1768 } else {
1769 return 0;
1770 }
1771 } else {
1772 PyErr_Clear();
1773 }
1774 if (val) {
1775 SWIG_type_error(errmsg, obj);
1776 }
1777 return 0;
1778 }
1779 #else
1780 SWIGINTERNSHORT int
1781 SWIG_AsVal_int(PyObject *obj, int *val)
1782 {
1783 return SWIG_AsVal_long(obj,(long*)val);
1784 }
1785 #endif
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_As_int(PyObject* obj)
1790 {
1791 int v;
1792 if (!SWIG_AsVal_int(obj, &v)) {
1793 /*
1794 this is needed to make valgrind/purify happier.
1795 */
1796 memset((void*)&v, 0, sizeof(int));
1797 }
1798 return v;
1799 }
1800
1801
1802 SWIGINTERNSHORT int
1803 SWIG_Check_int(PyObject* obj)
1804 {
1805 return SWIG_AsVal_int(obj, (int*)0);
1806 }
1807
1808 static PyObject *wxSize_Get(wxSize *self){
1809 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1810 PyObject* tup = PyTuple_New(2);
1811 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1812 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1813 wxPyEndBlockThreads(blocked);
1814 return tup;
1815 }
1816
1817 SWIGINTERN int
1818 SWIG_AsVal_double(PyObject *obj, double* val)
1819 {
1820 if (PyNumber_Check(obj)) {
1821 if (val) *val = PyFloat_AsDouble(obj);
1822 return 1;
1823 }
1824 else {
1825 SWIG_type_error("number", obj);
1826 }
1827 return 0;
1828 }
1829
1830
1831 SWIGINTERNSHORT double
1832 SWIG_As_double(PyObject* obj)
1833 {
1834 double v;
1835 if (!SWIG_AsVal_double(obj, &v)) {
1836 /*
1837 this is needed to make valgrind/purify happier.
1838 */
1839 memset((void*)&v, 0, sizeof(double));
1840 }
1841 return v;
1842 }
1843
1844
1845 SWIGINTERNSHORT int
1846 SWIG_Check_double(PyObject* obj)
1847 {
1848 return SWIG_AsVal_double(obj, (double*)0);
1849 }
1850
1851
1852 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1853 #define SWIG_From_double PyFloat_FromDouble
1854 /*@@*/
1855
1856 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1857 self->x = x;
1858 self->y = y;
1859 }
1860 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1861 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1862 PyObject* tup = PyTuple_New(2);
1863 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1864 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1865 wxPyEndBlockThreads(blocked);
1866 return tup;
1867 }
1868
1869 SWIGINTERNSHORT long
1870 SWIG_As_long(PyObject* obj)
1871 {
1872 long v;
1873 if (!SWIG_AsVal_long(obj, &v)) {
1874 /*
1875 this is needed to make valgrind/purify happier.
1876 */
1877 memset((void*)&v, 0, sizeof(long));
1878 }
1879 return v;
1880 }
1881
1882
1883 SWIGINTERNSHORT int
1884 SWIG_Check_long(PyObject* obj)
1885 {
1886 return SWIG_AsVal_long(obj, (long*)0);
1887 }
1888
1889 static void wxPoint_Set(wxPoint *self,long x,long y){
1890 self->x = x;
1891 self->y = y;
1892 }
1893 static PyObject *wxPoint_Get(wxPoint *self){
1894 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1895 PyObject* tup = PyTuple_New(2);
1896 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1897 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1898 wxPyEndBlockThreads(blocked);
1899 return tup;
1900 }
1901 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1902 self->x = x;
1903 self->y = y;
1904 self->width = width;
1905 self->height = height;
1906 }
1907 static PyObject *wxRect_Get(wxRect *self){
1908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1909 PyObject* tup = PyTuple_New(4);
1910 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1911 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1912 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1913 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1914 wxPyEndBlockThreads(blocked);
1915 return tup;
1916 }
1917
1918 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1919 wxRegion reg1(*r1);
1920 wxRegion reg2(*r2);
1921 wxRect dest(0,0,0,0);
1922 PyObject* obj;
1923
1924 reg1.Intersect(reg2);
1925 dest = reg1.GetBox();
1926
1927 if (dest != wxRect(0,0,0,0)) {
1928 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1929 wxRect* newRect = new wxRect(dest);
1930 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1931 wxPyEndBlockThreads(blocked);
1932 return obj;
1933 }
1934 Py_INCREF(Py_None);
1935 return Py_None;
1936 }
1937
1938
1939 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1940 PyObject* o2;
1941 PyObject* o3;
1942
1943 if (!target) {
1944 target = o;
1945 } else if (target == Py_None) {
1946 Py_DECREF(Py_None);
1947 target = o;
1948 } else {
1949 if (!PyTuple_Check(target)) {
1950 o2 = target;
1951 target = PyTuple_New(1);
1952 PyTuple_SetItem(target, 0, o2);
1953 }
1954 o3 = PyTuple_New(1);
1955 PyTuple_SetItem(o3, 0, o);
1956
1957 o2 = target;
1958 target = PySequence_Concat(o2, o3);
1959 Py_DECREF(o2);
1960 Py_DECREF(o3);
1961 }
1962 return target;
1963 }
1964
1965
1966 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1967 self->m_x = x;
1968 self->m_y = y;
1969 }
1970 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1971 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1972 PyObject* tup = PyTuple_New(2);
1973 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1974 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1975 wxPyEndBlockThreads(blocked);
1976 return tup;
1977 }
1978
1979 #include "wx/wxPython/pyistream.h"
1980
1981 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1982 wxInputStream* wxis = wxPyCBInputStream::create(p);
1983 if (wxis)
1984 return new wxPyInputStream(wxis);
1985 else
1986 return NULL;
1987 }
1988
1989 SWIGINTERNSHORT PyObject*
1990 SWIG_From_char(char c)
1991 {
1992 return PyString_FromStringAndSize(&c,1);
1993 }
1994
1995
1996 SWIGINTERNSHORT PyObject*
1997 SWIG_From_unsigned_SS_long(unsigned long value)
1998 {
1999 return (value > LONG_MAX) ?
2000 PyLong_FromUnsignedLong(value)
2001 : PyInt_FromLong((long)(value));
2002 }
2003
2004
2005 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2006 SWIGINTERN int
2007 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2008 {
2009 static swig_type_info* pchar_info = 0;
2010 char* vptr = 0;
2011 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2012 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2013 if (cptr) *cptr = vptr;
2014 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2015 return SWIG_OLDOBJ;
2016 } else {
2017 PyErr_Clear();
2018 if (PyString_Check(obj)) {
2019 if (cptr) {
2020 *cptr = PyString_AS_STRING(obj);
2021 if (psize) {
2022 *psize = PyString_GET_SIZE(obj) + 1;
2023 }
2024 }
2025 return SWIG_PYSTR;
2026 }
2027 }
2028 if (cptr) {
2029 SWIG_type_error("char *", obj);
2030 }
2031 return 0;
2032 }
2033
2034
2035 SWIGINTERN int
2036 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2037 {
2038 char* cptr; size_t csize;
2039 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2040 /* in C you can do:
2041
2042 char x[5] = "hello";
2043
2044 ie, assing the array using an extra '0' char.
2045 */
2046 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2047 if (csize <= size) {
2048 if (val) {
2049 if (csize) memcpy(val, cptr, csize);
2050 if (csize < size) memset(val + csize, 0, size - csize);
2051 }
2052 return 1;
2053 }
2054 }
2055 if (val) {
2056 PyErr_Format(PyExc_TypeError,
2057 "a char array of maximum size %lu is expected",
2058 (unsigned long) size);
2059 }
2060 return 0;
2061 }
2062
2063
2064 SWIGINTERN int
2065 SWIG_AsVal_char(PyObject *obj, char *val)
2066 {
2067 const char* errmsg = val ? "char" : (char*)0;
2068 long v;
2069 if (SWIG_AsVal_long(obj, &v)) {
2070 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2071 if (val) *val = (char)(v);
2072 return 1;
2073 } else {
2074 return 0;
2075 }
2076 } else {
2077 PyErr_Clear();
2078 return SWIG_AsCharArray(obj, val, 1);
2079 }
2080 }
2081
2082
2083 SWIGINTERNSHORT char
2084 SWIG_As_char(PyObject* obj)
2085 {
2086 char v;
2087 if (!SWIG_AsVal_char(obj, &v)) {
2088 /*
2089 this is needed to make valgrind/purify happier.
2090 */
2091 memset((void*)&v, 0, sizeof(char));
2092 }
2093 return v;
2094 }
2095
2096
2097 SWIGINTERNSHORT int
2098 SWIG_Check_char(PyObject* obj)
2099 {
2100 return SWIG_AsVal_char(obj, (char*)0);
2101 }
2102
2103
2104 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2105 #define SWIG_From_long PyInt_FromLong
2106 /*@@*/
2107
2108 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2109 // We use only strings for the streams, not unicode
2110 PyObject* str = PyObject_Str(obj);
2111 if (! str) {
2112 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2113 return;
2114 }
2115 self->Write(PyString_AS_STRING(str),
2116 PyString_GET_SIZE(str));
2117 Py_DECREF(str);
2118 }
2119
2120 #include "wx/wxPython/pyistream.h"
2121
2122
2123 class wxPyFileSystemHandler : public wxFileSystemHandler
2124 {
2125 public:
2126 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2127
2128 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2129 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2130 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2131 DEC_PYCALLBACK_STRING__pure(FindNext);
2132
2133 wxString GetProtocol(const wxString& location) {
2134 return wxFileSystemHandler::GetProtocol(location);
2135 }
2136
2137 wxString GetLeftLocation(const wxString& location) {
2138 return wxFileSystemHandler::GetLeftLocation(location);
2139 }
2140
2141 wxString GetAnchor(const wxString& location) {
2142 return wxFileSystemHandler::GetAnchor(location);
2143 }
2144
2145 wxString GetRightLocation(const wxString& location) {
2146 return wxFileSystemHandler::GetRightLocation(location);
2147 }
2148
2149 wxString GetMimeTypeFromExt(const wxString& location) {
2150 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2151 }
2152
2153 PYPRIVATE;
2154 };
2155
2156
2157 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2158 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2159 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2160 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2161
2162
2163 SWIGINTERN int
2164 SWIG_AsVal_bool(PyObject *obj, bool *val)
2165 {
2166 if (obj == Py_True) {
2167 if (val) *val = true;
2168 return 1;
2169 }
2170 if (obj == Py_False) {
2171 if (val) *val = false;
2172 return 1;
2173 }
2174 int res = 0;
2175 if (SWIG_AsVal_int(obj, &res)) {
2176 if (val) *val = res ? true : false;
2177 return 1;
2178 } else {
2179 PyErr_Clear();
2180 }
2181 if (val) {
2182 SWIG_type_error("bool", obj);
2183 }
2184 return 0;
2185 }
2186
2187
2188 SWIGINTERNSHORT bool
2189 SWIG_As_bool(PyObject* obj)
2190 {
2191 bool v;
2192 if (!SWIG_AsVal_bool(obj, &v)) {
2193 /*
2194 this is needed to make valgrind/purify happier.
2195 */
2196 memset((void*)&v, 0, sizeof(bool));
2197 }
2198 return v;
2199 }
2200
2201
2202 SWIGINTERNSHORT int
2203 SWIG_Check_bool(PyObject* obj)
2204 {
2205 return SWIG_AsVal_bool(obj, (bool*)0);
2206 }
2207
2208 static wxString FileSystem_URLToFileName(wxString const &url){
2209 wxFileName fname = wxFileSystem::URLToFileName(url);
2210 return fname.GetFullPath();
2211 }
2212
2213 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2214 wxImage& image,
2215 long type) {
2216 wxMemoryFSHandler::AddFile(filename, image, type);
2217 }
2218
2219 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2220 const wxBitmap& bitmap,
2221 long type) {
2222 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2223 }
2224
2225 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2226 PyObject* data) {
2227 if (! PyString_Check(data)) {
2228 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2229 "Expected string object"));
2230 return;
2231 }
2232
2233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2234 void* ptr = (void*)PyString_AsString(data);
2235 size_t size = PyString_Size(data);
2236 wxPyEndBlockThreads(blocked);
2237
2238 wxMemoryFSHandler::AddFile(filename, ptr, size);
2239 }
2240
2241
2242 #include "wx/wxPython/pyistream.h"
2243
2244
2245 SWIGINTERN int
2246 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2247 {
2248 long v = 0;
2249 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2250 SWIG_type_error("unsigned number", obj);
2251 }
2252 else if (val)
2253 *val = (unsigned long)v;
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERNSHORT int
2259 SWIG_CheckUnsignedLongInRange(unsigned long value,
2260 unsigned long max_value,
2261 const char *errmsg)
2262 {
2263 if (value > max_value) {
2264 if (errmsg) {
2265 PyErr_Format(PyExc_OverflowError,
2266 "value %lu is greater than '%s' minimum %lu",
2267 value, errmsg, max_value);
2268 }
2269 return 0;
2270 }
2271 return 1;
2272 }
2273
2274
2275 SWIGINTERN int
2276 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2277 {
2278 const char* errmsg = val ? "unsigned char" : (char*)0;
2279 unsigned long v;
2280 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2281 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2282 if (val) *val = (unsigned char)(v);
2283 return 1;
2284 } else {
2285 return 0;
2286 }
2287 } else {
2288 PyErr_Clear();
2289 }
2290 if (val) {
2291 SWIG_type_error(errmsg, obj);
2292 }
2293 return 0;
2294 }
2295
2296
2297 SWIGINTERNSHORT unsigned char
2298 SWIG_As_unsigned_SS_char(PyObject* obj)
2299 {
2300 unsigned char v;
2301 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2302 /*
2303 this is needed to make valgrind/purify happier.
2304 */
2305 memset((void*)&v, 0, sizeof(unsigned char));
2306 }
2307 return v;
2308 }
2309
2310
2311 SWIGINTERNSHORT int
2312 SWIG_Check_unsigned_SS_char(PyObject* obj)
2313 {
2314 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2315 }
2316
2317
2318 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2319 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2320 /*@@*/
2321
2322
2323
2324 SWIGINTERNSHORT unsigned long
2325 SWIG_As_unsigned_SS_long(PyObject* obj)
2326 {
2327 unsigned long v;
2328 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2329 /*
2330 this is needed to make valgrind/purify happier.
2331 */
2332 memset((void*)&v, 0, sizeof(unsigned long));
2333 }
2334 return v;
2335 }
2336
2337
2338 SWIGINTERNSHORT int
2339 SWIG_Check_unsigned_SS_long(PyObject* obj)
2340 {
2341 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2342 }
2343
2344 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2345 wxImageHistogramEntry e = (*self)[key];
2346 return e.value;
2347 }
2348 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2349 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2350 wxImageHistogramEntry e = (*self)[key];
2351 return e.value;
2352 }
2353 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2354 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2355 colour.Green(),
2356 colour.Blue());
2357 wxImageHistogramEntry e = (*self)[key];
2358 return e.value;
2359 }
2360
2361 typedef unsigned char* buffer;
2362
2363
2364 // Pull the nested class out to the top level for SWIG's sake
2365 #define wxImage_RGBValue wxImage::RGBValue
2366 #define wxImage_HSVValue wxImage::HSVValue
2367
2368 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2369 if (width > 0 && height > 0)
2370 return new wxImage(width, height, clear);
2371 else
2372 return new wxImage;
2373 }
2374 static wxImage *new_wxImage(wxBitmap const &bitmap){
2375 return new wxImage(bitmap.ConvertToImage());
2376 }
2377 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2378 if (DATASIZE != width*height*3) {
2379 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2380 return NULL;
2381 }
2382
2383 // Copy the source data so the wxImage can clean it up later
2384 buffer copy = (buffer)malloc(DATASIZE);
2385 if (copy == NULL) {
2386 wxPyBLOCK_THREADS(PyErr_NoMemory());
2387 return NULL;
2388 }
2389 memcpy(copy, data, DATASIZE);
2390 return new wxImage(width, height, copy, false);
2391 }
2392 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2393 if (DATASIZE != width*height*3) {
2394 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2395 return NULL;
2396 }
2397 if (ALPHASIZE != width*height) {
2398 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2399 return NULL;
2400 }
2401
2402 // Copy the source data so the wxImage can clean it up later
2403 buffer dcopy = (buffer)malloc(DATASIZE);
2404 if (dcopy == NULL) {
2405 wxPyBLOCK_THREADS(PyErr_NoMemory());
2406 return NULL;
2407 }
2408 memcpy(dcopy, data, DATASIZE);
2409
2410 buffer acopy = (buffer)malloc(ALPHASIZE);
2411 if (acopy == NULL) {
2412 wxPyBLOCK_THREADS(PyErr_NoMemory());
2413 return NULL;
2414 }
2415 memcpy(acopy, alpha, ALPHASIZE);
2416
2417 return new wxImage(width, height, dcopy, acopy, false);
2418 }
2419 static wxSize wxImage_GetSize(wxImage *self){
2420 wxSize size(self->GetWidth(), self->GetHeight());
2421 return size;
2422 }
2423 static PyObject *wxImage_GetData(wxImage *self){
2424 buffer data = self->GetData();
2425 int len = self->GetWidth() * self->GetHeight() * 3;
2426 PyObject* rv;
2427 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2428 return rv;
2429 }
2430 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2431 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2432 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2433 return;
2434 }
2435 buffer copy = (buffer)malloc(DATASIZE);
2436 if (copy == NULL) {
2437 wxPyBLOCK_THREADS(PyErr_NoMemory());
2438 return;
2439 }
2440 memcpy(copy, data, DATASIZE);
2441 self->SetData(copy, false);
2442 // wxImage takes ownership of copy...
2443 }
2444 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2445 buffer data = self->GetData();
2446 int len = self->GetWidth() * self->GetHeight() * 3;
2447 PyObject* rv;
2448 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2449 return rv;
2450 }
2451 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2452 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2453 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2454 return;
2455 }
2456 self->SetData(data, true);
2457 }
2458 static PyObject *wxImage_GetAlphaData(wxImage *self){
2459 buffer data = self->GetAlpha();
2460 if (! data) {
2461 RETURN_NONE();
2462 } else {
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2466 return rv;
2467 }
2468 }
2469 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2470 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2471 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2472 return;
2473 }
2474 buffer acopy = (buffer)malloc(ALPHASIZE);
2475 if (acopy == NULL) {
2476 wxPyBLOCK_THREADS(PyErr_NoMemory());
2477 return;
2478 }
2479 memcpy(acopy, alpha, ALPHASIZE);
2480 self->SetAlpha(acopy, false);
2481 // wxImage takes ownership of acopy...
2482 }
2483 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2484 buffer data = self->GetAlpha();
2485 int len = self->GetWidth() * self->GetHeight();
2486 PyObject* rv;
2487 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2488 return rv;
2489 }
2490 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2491 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2492 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2493 return;
2494 }
2495 self->SetAlpha(alpha, true);
2496 }
2497 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2498 wxBitmap bitmap(*self, depth);
2499 return bitmap;
2500 }
2501 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2502 wxImage mono = self->ConvertToMono( red, green, blue );
2503 wxBitmap bitmap( mono, 1 );
2504 return bitmap;
2505 }
2506 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2507 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2508 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2509 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2510 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2511 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2512 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2513 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2514 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2515 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2516 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2517 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2518 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2519 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2520 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2521
2522 #include <wx/quantize.h>
2523
2524 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2525 return wxQuantize::Quantize(src, dest,
2526 //NULL, // palette
2527 desiredNoColours,
2528 NULL, // eightBitData
2529 flags);
2530 }
2531 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2532 if (PyCallable_Check(func)) {
2533 self->Connect(id, lastId, eventType,
2534 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2535 new wxPyCallback(func));
2536 }
2537 else if (func == Py_None) {
2538 self->Disconnect(id, lastId, eventType,
2539 (wxObjectEventFunction)
2540 &wxPyCallback::EventThunker);
2541 }
2542 else {
2543 wxPyBLOCK_THREADS(
2544 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2545 }
2546 }
2547 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2548 return self->Disconnect(id, lastId, eventType,
2549 (wxObjectEventFunction)
2550 &wxPyCallback::EventThunker);
2551 }
2552 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2553 if (_self && _self != Py_None) {
2554 self->SetClientObject(new wxPyOORClientData(_self, incref));
2555 }
2556 else {
2557 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2558 if (data) {
2559 self->SetClientObject(NULL); // This will delete it too
2560 }
2561 }
2562 }
2563
2564 #if ! wxUSE_HOTKEY
2565 #define wxEVT_HOTKEY -9999
2566 #endif
2567
2568
2569 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2570 #if wxUSE_UNICODE
2571 return self->GetUnicodeKey();
2572 #else
2573 return 0;
2574 #endif
2575 }
2576
2577 #if UINT_MAX < LONG_MAX
2578 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2579 #define SWIG_From_unsigned_SS_int SWIG_From_long
2580 /*@@*/
2581 #else
2582 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2583 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2584 /*@@*/
2585 #endif
2586
2587
2588 #if UINT_MAX != ULONG_MAX
2589 SWIGINTERN int
2590 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2591 {
2592 const char* errmsg = val ? "unsigned int" : (char*)0;
2593 unsigned long v;
2594 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2595 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2596 if (val) *val = (unsigned int)(v);
2597 return 1;
2598 }
2599 } else {
2600 PyErr_Clear();
2601 }
2602 if (val) {
2603 SWIG_type_error(errmsg, obj);
2604 }
2605 return 0;
2606 }
2607 #else
2608 SWIGINTERNSHORT unsigned int
2609 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2610 {
2611 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2612 }
2613 #endif
2614
2615
2616 SWIGINTERNSHORT unsigned int
2617 SWIG_As_unsigned_SS_int(PyObject* obj)
2618 {
2619 unsigned int v;
2620 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2621 /*
2622 this is needed to make valgrind/purify happier.
2623 */
2624 memset((void*)&v, 0, sizeof(unsigned int));
2625 }
2626 return v;
2627 }
2628
2629
2630 SWIGINTERNSHORT int
2631 SWIG_Check_unsigned_SS_int(PyObject* obj)
2632 {
2633 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2634 }
2635
2636 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2637 self->m_size = size;
2638 }
2639 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2640 int count = self->GetNumberOfFiles();
2641 wxString* files = self->GetFiles();
2642 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2643 PyObject* list = PyList_New(count);
2644
2645 if (!list) {
2646 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2647 wxPyEndBlockThreads(blocked);
2648 return NULL;
2649 }
2650
2651 for (int i=0; i<count; i++) {
2652 PyList_SetItem(list, i, wx2PyString(files[i]));
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return list;
2656 }
2657
2658
2659 static wxPyApp *new_wxPyApp(){
2660 wxPythonApp = new wxPyApp();
2661 return wxPythonApp;
2662 }
2663 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2664
2665 void wxApp_CleanUp() {
2666 __wxPyCleanup();
2667 }
2668
2669
2670 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2671
2672
2673 SWIGINTERNSHORT int
2674 SWIG_AsCharPtr(PyObject *obj, char **val)
2675 {
2676 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2677 return 1;
2678 }
2679 if (val) {
2680 PyErr_Clear();
2681 SWIG_type_error("char *", obj);
2682 }
2683 return 0;
2684 }
2685
2686
2687 SWIGINTERN PyObject *
2688 SWIG_FromCharPtr(const char* cptr)
2689 {
2690 if (cptr) {
2691 size_t size = strlen(cptr);
2692 if (size > INT_MAX) {
2693 return SWIG_NewPointerObj((char*)(cptr),
2694 SWIG_TypeQuery("char *"), 0);
2695 } else {
2696 if (size != 0) {
2697 return PyString_FromStringAndSize(cptr, size);
2698 } else {
2699 return PyString_FromString(cptr);
2700 }
2701 }
2702 }
2703 Py_INCREF(Py_None);
2704 return Py_None;
2705 }
2706
2707
2708 #ifdef __WXMAC__
2709
2710 // A dummy class that raises an exception if used...
2711 class wxEventLoop
2712 {
2713 public:
2714 wxEventLoop() { wxPyRaiseNotImplemented(); }
2715 int Run() { return 0; }
2716 void Exit(int rc = 0) {}
2717 bool Pending() const { return false; }
2718 bool Dispatch() { return false; }
2719 bool IsRunning() const { return false; }
2720 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2721 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2722 };
2723
2724 #else
2725
2726 #include <wx/evtloop.h>
2727
2728 #endif
2729
2730
2731
2732 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2733 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2734 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2735 static PyObject *wxWindow_GetChildren(wxWindow *self){
2736 wxWindowList& list = self->GetChildren();
2737 return wxPy_ConvertList(&list);
2738 }
2739 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2740 #if wxUSE_HOTKEY
2741 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2742 #else
2743 return false;
2744 #endif
2745 }
2746 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2747
2748
2749
2750 return false;
2751
2752 }
2753 static long wxWindow_GetHandle(wxWindow *self){
2754 return wxPyGetWinHandle(self);
2755 }
2756 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2757 self->AssociateHandle((WXWidget)handle);
2758 }
2759 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2760
2761 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2762 return wxWindow::FindWindowById(id, parent);
2763 }
2764
2765 wxWindow* wxFindWindowByName( const wxString& name,
2766 const wxWindow *parent = NULL ) {
2767 return wxWindow::FindWindowByName(name, parent);
2768 }
2769
2770 wxWindow* wxFindWindowByLabel( const wxString& label,
2771 const wxWindow *parent = NULL ) {
2772 return wxWindow::FindWindowByLabel(label, parent);
2773 }
2774
2775
2776 #ifdef __WXMSW__
2777 #include <wx/msw/private.h> // to get wxGetWindowId
2778 #endif
2779
2780
2781 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2782 #ifdef __WXMSW__
2783 WXHWND hWnd = (WXHWND)_hWnd;
2784 long id = wxGetWindowId(hWnd);
2785 wxWindow* win = new wxWindow;
2786 if (parent)
2787 parent->AddChild(win);
2788 win->SetEventHandler(win);
2789 win->SetHWND(hWnd);
2790 win->SetId(id);
2791 win->SubclassWin(hWnd);
2792 win->AdoptAttributesFromHWND();
2793 win->SetupColours();
2794 return win;
2795 #else
2796 wxPyRaiseNotImplemented();
2797 return NULL;
2798 #endif
2799 }
2800
2801
2802 PyObject* GetTopLevelWindows() {
2803 return wxPy_ConvertList(&wxTopLevelWindows);
2804 }
2805
2806
2807 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2808 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2809 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2810
2811 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2812
2813 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2814 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2815 wxMenuItemList& list = self->GetMenuItems();
2816 return wxPy_ConvertList(&list);
2817 }
2818 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2819 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2820 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2821 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2822 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2823 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2824 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2825 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2826 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2827 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2828 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2829 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2830 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2831 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2832 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2833 static const wxString wxPyControlNameStr(wxControlNameStr);
2834 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2835 if (clientData) {
2836 wxPyClientData* data = new wxPyClientData(clientData);
2837 return self->Append(item, data);
2838 } else
2839 return self->Append(item);
2840 }
2841 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2842 if (clientData) {
2843 wxPyClientData* data = new wxPyClientData(clientData);
2844 return self->Insert(item, pos, data);
2845 } else
2846 return self->Insert(item, pos);
2847 }
2848 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2849 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2850 if (data) {
2851 Py_INCREF(data->m_obj);
2852 return data->m_obj;
2853 } else {
2854 Py_INCREF(Py_None);
2855 return Py_None;
2856 }
2857 }
2858 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2859 wxPyClientData* data = new wxPyClientData(clientData);
2860 self->SetClientObject(n, data);
2861 }
2862
2863
2864 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2865 wxPyUserData* data = NULL;
2866 if ( userData ) {
2867 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2868 data = new wxPyUserData(userData);
2869 wxPyEndBlockThreads(blocked);
2870 }
2871 return new wxSizerItem(window, proportion, flag, border, data);
2872 }
2873 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2874 wxPyUserData* data = NULL;
2875 if ( userData ) {
2876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2877 data = new wxPyUserData(userData);
2878 wxPyEndBlockThreads(blocked);
2879 }
2880 return new wxSizerItem(width, height, proportion, flag, border, data);
2881 }
2882 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2883 wxPyUserData* data = NULL;
2884 if ( userData ) {
2885 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2886 data = new wxPyUserData(userData);
2887 wxPyEndBlockThreads(blocked);
2888 }
2889 return new wxSizerItem(sizer, proportion, flag, border, data);
2890 }
2891
2892 #include <float.h>
2893 SWIGINTERN int
2894 SWIG_CheckDoubleInRange(double value, double min_value,
2895 double max_value, const char* errmsg)
2896 {
2897 if (value < min_value) {
2898 if (errmsg) {
2899 PyErr_Format(PyExc_OverflowError,
2900 "value %g is less than %s minimum %g",
2901 value, errmsg, min_value);
2902 }
2903 return 0;
2904 } else if (value > max_value) {
2905 if (errmsg) {
2906 PyErr_Format(PyExc_OverflowError,
2907 "value %g is greater than %s maximum %g",
2908 value, errmsg, max_value);
2909 }
2910 return 0;
2911 }
2912 return 1;
2913 }
2914
2915
2916 SWIGINTERN int
2917 SWIG_AsVal_float(PyObject *obj, float *val)
2918 {
2919 const char* errmsg = val ? "float" : (char*)0;
2920 double v;
2921 if (SWIG_AsVal_double(obj, &v)) {
2922 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2923 if (val) *val = (float)(v);
2924 return 1;
2925 } else {
2926 return 0;
2927 }
2928 } else {
2929 PyErr_Clear();
2930 }
2931 if (val) {
2932 SWIG_type_error(errmsg, obj);
2933 }
2934 return 0;
2935 }
2936
2937
2938 SWIGINTERNSHORT float
2939 SWIG_As_float(PyObject* obj)
2940 {
2941 float v;
2942 if (!SWIG_AsVal_float(obj, &v)) {
2943 /*
2944 this is needed to make valgrind/purify happier.
2945 */
2946 memset((void*)&v, 0, sizeof(float));
2947 }
2948 return v;
2949 }
2950
2951
2952 SWIGINTERNSHORT int
2953 SWIG_Check_float(PyObject* obj)
2954 {
2955 return SWIG_AsVal_float(obj, (float*)0);
2956 }
2957
2958
2959 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2960 #define SWIG_From_float PyFloat_FromDouble
2961 /*@@*/
2962
2963 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2964 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2965 if (data) {
2966 Py_INCREF(data->m_obj);
2967 return data->m_obj;
2968 } else {
2969 Py_INCREF(Py_None);
2970 return Py_None;
2971 }
2972 }
2973
2974 // Figure out the type of the sizer item
2975
2976 struct wxPySizerItemInfo {
2977 wxPySizerItemInfo()
2978 : window(NULL), sizer(NULL), gotSize(false),
2979 size(wxDefaultSize), gotPos(false), pos(-1)
2980 {}
2981
2982 wxWindow* window;
2983 wxSizer* sizer;
2984 bool gotSize;
2985 wxSize size;
2986 bool gotPos;
2987 int pos;
2988 };
2989
2990 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2991
2992 wxPySizerItemInfo info;
2993 wxSize size;
2994 wxSize* sizePtr = &size;
2995
2996 // Find out what the type of the item is
2997 // try wxWindow
2998 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2999 PyErr_Clear();
3000 info.window = NULL;
3001
3002 // try wxSizer
3003 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3004 PyErr_Clear();
3005 info.sizer = NULL;
3006
3007 // try wxSize or (w,h)
3008 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3009 info.size = *sizePtr;
3010 info.gotSize = true;
3011 }
3012
3013 // or a single int
3014 if (checkIdx && PyInt_Check(item)) {
3015 info.pos = PyInt_AsLong(item);
3016 info.gotPos = true;
3017 }
3018 }
3019 }
3020
3021 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3022 // no expected type, figure out what kind of error message to generate
3023 if ( !checkSize && !checkIdx )
3024 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3025 else if ( checkSize && !checkIdx )
3026 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3027 else if ( !checkSize && checkIdx)
3028 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3029 else
3030 // can this one happen?
3031 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3032 }
3033
3034 return info;
3035 }
3036
3037 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3038 if (!self->GetClientObject())
3039 self->SetClientObject(new wxPyOORClientData(_self));
3040 }
3041 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3042
3043 wxPyUserData* data = NULL;
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3046 if ( userData && (info.window || info.sizer || info.gotSize) )
3047 data = new wxPyUserData(userData);
3048 wxPyEndBlockThreads(blocked);
3049
3050 // Now call the real Add method if a valid item type was found
3051 if ( info.window )
3052 return self->Add(info.window, proportion, flag, border, data);
3053 else if ( info.sizer )
3054 return self->Add(info.sizer, proportion, flag, border, data);
3055 else if (info.gotSize)
3056 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3057 proportion, flag, border, data);
3058 else
3059 return NULL;
3060 }
3061 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3062
3063 wxPyUserData* data = NULL;
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3066 if ( userData && (info.window || info.sizer || info.gotSize) )
3067 data = new wxPyUserData(userData);
3068 wxPyEndBlockThreads(blocked);
3069
3070 // Now call the real Insert method if a valid item type was found
3071 if ( info.window )
3072 return self->Insert(before, info.window, proportion, flag, border, data);
3073 else if ( info.sizer )
3074 return self->Insert(before, info.sizer, proportion, flag, border, data);
3075 else if (info.gotSize)
3076 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3077 proportion, flag, border, data);
3078 else
3079 return NULL;
3080 }
3081 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3082
3083 wxPyUserData* data = NULL;
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3086 if ( userData && (info.window || info.sizer || info.gotSize) )
3087 data = new wxPyUserData(userData);
3088 wxPyEndBlockThreads(blocked);
3089
3090 // Now call the real Prepend method if a valid item type was found
3091 if ( info.window )
3092 return self->Prepend(info.window, proportion, flag, border, data);
3093 else if ( info.sizer )
3094 return self->Prepend(info.sizer, proportion, flag, border, data);
3095 else if (info.gotSize)
3096 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3097 proportion, flag, border, data);
3098 else
3099 return NULL;
3100 }
3101 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3104 wxPyEndBlockThreads(blocked);
3105 if ( info.window )
3106 return self->Remove(info.window);
3107 else if ( info.sizer )
3108 return self->Remove(info.sizer);
3109 else if ( info.gotPos )
3110 return self->Remove(info.pos);
3111 else
3112 return false;
3113 }
3114 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3115 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3117 wxPyEndBlockThreads(blocked);
3118 if ( info.window )
3119 return self->Detach(info.window);
3120 else if ( info.sizer )
3121 return self->Detach(info.sizer);
3122 else if ( info.gotPos )
3123 return self->Detach(info.pos);
3124 else
3125 return false;
3126 }
3127 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3130 wxPyEndBlockThreads(blocked);
3131 if ( info.window )
3132 return self->GetItem(info.window);
3133 else if ( info.sizer )
3134 return self->GetItem(info.sizer);
3135 else if ( info.gotPos )
3136 return self->GetItem(info.pos);
3137 else
3138 return NULL;
3139 }
3140 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3143 wxPyEndBlockThreads(blocked);
3144 if ( info.window )
3145 self->SetItemMinSize(info.window, size);
3146 else if ( info.sizer )
3147 self->SetItemMinSize(info.sizer, size);
3148 else if ( info.gotPos )
3149 self->SetItemMinSize(info.pos, size);
3150 }
3151 static PyObject *wxSizer_GetChildren(wxSizer *self){
3152 wxSizerItemList& list = self->GetChildren();
3153 return wxPy_ConvertList(&list);
3154 }
3155 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3157 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3158 wxPyEndBlockThreads(blocked);
3159 if ( info.window )
3160 return self->Show(info.window, show, recursive);
3161 else if ( info.sizer )
3162 return self->Show(info.sizer, show, recursive);
3163 else if ( info.gotPos )
3164 return self->Show(info.pos, show);
3165 else
3166 return false;
3167 }
3168 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3171 wxPyEndBlockThreads(blocked);
3172 if ( info.window )
3173 return self->IsShown(info.window);
3174 else if ( info.sizer )
3175 return self->IsShown(info.sizer);
3176 else if ( info.gotPos )
3177 return self->IsShown(info.pos);
3178 else
3179 return false;
3180 }
3181
3182 // See pyclasses.h
3183 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3184 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3185 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3186
3187
3188
3189
3190 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3191 {
3192 if (source == Py_None) {
3193 **obj = wxGBPosition(-1,-1);
3194 return true;
3195 }
3196 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3197 }
3198
3199 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3200 {
3201 if (source == Py_None) {
3202 **obj = wxGBSpan(-1,-1);
3203 return true;
3204 }
3205 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3206 }
3207
3208
3209 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3210 self->SetRow(row);
3211 self->SetCol(col);
3212 }
3213 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyObject* tup = PyTuple_New(2);
3216 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3217 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3218 wxPyEndBlockThreads(blocked);
3219 return tup;
3220 }
3221 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3222 self->SetRowspan(rowspan);
3223 self->SetColspan(colspan);
3224 }
3225 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3227 PyObject* tup = PyTuple_New(2);
3228 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3229 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3230 wxPyEndBlockThreads(blocked);
3231 return tup;
3232 }
3233 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3234 wxPyUserData* data = NULL;
3235 if ( userData ) {
3236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3237 data = new wxPyUserData(userData);
3238 wxPyEndBlockThreads(blocked);
3239 }
3240 return new wxGBSizerItem(window, pos, span, flag, border, data);
3241 }
3242 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3243 wxPyUserData* data = NULL;
3244 if ( userData ) {
3245 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3246 data = new wxPyUserData(userData);
3247 wxPyEndBlockThreads(blocked);
3248 }
3249 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3250 }
3251 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3252 wxPyUserData* data = NULL;
3253 if ( userData ) {
3254 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3255 data = new wxPyUserData(userData);
3256 wxPyEndBlockThreads(blocked);
3257 }
3258 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3259 }
3260 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3261 int row, col;
3262 self->GetEndPos(row, col);
3263 return wxGBPosition(row, col);
3264 }
3265 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3266
3267 wxPyUserData* data = NULL;
3268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3269 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3270 if ( userData && (info.window || info.sizer || info.gotSize) )
3271 data = new wxPyUserData(userData);
3272 wxPyEndBlockThreads(blocked);
3273
3274 // Now call the real Add method if a valid item type was found
3275 if ( info.window )
3276 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3277 else if ( info.sizer )
3278 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3279 else if (info.gotSize)
3280 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3281 pos, span, flag, border, data);
3282 return NULL;
3283 }
3284
3285
3286 #ifdef __cplusplus
3287 extern "C" {
3288 #endif
3289 static int _wrap_EmptyString_set(PyObject *) {
3290 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3291 return 1;
3292 }
3293
3294
3295 static PyObject *_wrap_EmptyString_get(void) {
3296 PyObject *pyobj;
3297
3298 {
3299 #if wxUSE_UNICODE
3300 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3301 #else
3302 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3303 #endif
3304 }
3305 return pyobj;
3306 }
3307
3308
3309 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3310 PyObject *resultobj;
3311 wxObject *arg1 = (wxObject *) 0 ;
3312 wxString result;
3313 PyObject * obj0 = 0 ;
3314 char *kwnames[] = {
3315 (char *) "self", NULL
3316 };
3317
3318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3320 if (SWIG_arg_fail(1)) SWIG_fail;
3321 {
3322 PyThreadState* __tstate = wxPyBeginAllowThreads();
3323 result = wxObject_GetClassName(arg1);
3324
3325 wxPyEndAllowThreads(__tstate);
3326 if (PyErr_Occurred()) SWIG_fail;
3327 }
3328 {
3329 #if wxUSE_UNICODE
3330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3331 #else
3332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3333 #endif
3334 }
3335 return resultobj;
3336 fail:
3337 return NULL;
3338 }
3339
3340
3341 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3342 PyObject *resultobj;
3343 wxObject *arg1 = (wxObject *) 0 ;
3344 PyObject * obj0 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "self", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3351 if (SWIG_arg_fail(1)) SWIG_fail;
3352 {
3353 PyThreadState* __tstate = wxPyBeginAllowThreads();
3354 wxObject_Destroy(arg1);
3355
3356 wxPyEndAllowThreads(__tstate);
3357 if (PyErr_Occurred()) SWIG_fail;
3358 }
3359 Py_INCREF(Py_None); resultobj = Py_None;
3360 return resultobj;
3361 fail:
3362 return NULL;
3363 }
3364
3365
3366 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3367 PyObject *obj;
3368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3369 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3370 Py_INCREF(obj);
3371 return Py_BuildValue((char *)"");
3372 }
3373 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3374 PyObject *resultobj;
3375 wxSize *arg1 = (wxSize *) 0 ;
3376 int arg2 ;
3377 PyObject * obj0 = 0 ;
3378 PyObject * obj1 = 0 ;
3379 char *kwnames[] = {
3380 (char *) "self",(char *) "x", NULL
3381 };
3382
3383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3385 if (SWIG_arg_fail(1)) SWIG_fail;
3386 {
3387 arg2 = (int)(SWIG_As_int(obj1));
3388 if (SWIG_arg_fail(2)) SWIG_fail;
3389 }
3390 if (arg1) (arg1)->x = arg2;
3391
3392 Py_INCREF(Py_None); resultobj = Py_None;
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxSize *arg1 = (wxSize *) 0 ;
3402 int result;
3403 PyObject * obj0 = 0 ;
3404 char *kwnames[] = {
3405 (char *) "self", NULL
3406 };
3407
3408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3410 if (SWIG_arg_fail(1)) SWIG_fail;
3411 result = (int) ((arg1)->x);
3412
3413 {
3414 resultobj = SWIG_From_int((int)(result));
3415 }
3416 return resultobj;
3417 fail:
3418 return NULL;
3419 }
3420
3421
3422 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3423 PyObject *resultobj;
3424 wxSize *arg1 = (wxSize *) 0 ;
3425 int arg2 ;
3426 PyObject * obj0 = 0 ;
3427 PyObject * obj1 = 0 ;
3428 char *kwnames[] = {
3429 (char *) "self",(char *) "y", NULL
3430 };
3431
3432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3434 if (SWIG_arg_fail(1)) SWIG_fail;
3435 {
3436 arg2 = (int)(SWIG_As_int(obj1));
3437 if (SWIG_arg_fail(2)) SWIG_fail;
3438 }
3439 if (arg1) (arg1)->y = arg2;
3440
3441 Py_INCREF(Py_None); resultobj = Py_None;
3442 return resultobj;
3443 fail:
3444 return NULL;
3445 }
3446
3447
3448 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3449 PyObject *resultobj;
3450 wxSize *arg1 = (wxSize *) 0 ;
3451 int result;
3452 PyObject * obj0 = 0 ;
3453 char *kwnames[] = {
3454 (char *) "self", NULL
3455 };
3456
3457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3459 if (SWIG_arg_fail(1)) SWIG_fail;
3460 result = (int) ((arg1)->y);
3461
3462 {
3463 resultobj = SWIG_From_int((int)(result));
3464 }
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 int arg1 = (int) 0 ;
3474 int arg2 = (int) 0 ;
3475 wxSize *result;
3476 PyObject * obj0 = 0 ;
3477 PyObject * obj1 = 0 ;
3478 char *kwnames[] = {
3479 (char *) "w",(char *) "h", NULL
3480 };
3481
3482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3483 if (obj0) {
3484 {
3485 arg1 = (int)(SWIG_As_int(obj0));
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 }
3488 }
3489 if (obj1) {
3490 {
3491 arg2 = (int)(SWIG_As_int(obj1));
3492 if (SWIG_arg_fail(2)) SWIG_fail;
3493 }
3494 }
3495 {
3496 PyThreadState* __tstate = wxPyBeginAllowThreads();
3497 result = (wxSize *)new wxSize(arg1,arg2);
3498
3499 wxPyEndAllowThreads(__tstate);
3500 if (PyErr_Occurred()) SWIG_fail;
3501 }
3502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3503 return resultobj;
3504 fail:
3505 return NULL;
3506 }
3507
3508
3509 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3510 PyObject *resultobj;
3511 wxSize *arg1 = (wxSize *) 0 ;
3512 PyObject * obj0 = 0 ;
3513 char *kwnames[] = {
3514 (char *) "self", NULL
3515 };
3516
3517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3519 if (SWIG_arg_fail(1)) SWIG_fail;
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 delete arg1;
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 Py_INCREF(Py_None); resultobj = Py_None;
3528 return resultobj;
3529 fail:
3530 return NULL;
3531 }
3532
3533
3534 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3535 PyObject *resultobj;
3536 wxSize *arg1 = (wxSize *) 0 ;
3537 wxSize *arg2 = 0 ;
3538 bool result;
3539 wxSize temp2 ;
3540 PyObject * obj0 = 0 ;
3541 PyObject * obj1 = 0 ;
3542 char *kwnames[] = {
3543 (char *) "self",(char *) "sz", NULL
3544 };
3545
3546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3548 if (SWIG_arg_fail(1)) SWIG_fail;
3549 {
3550 arg2 = &temp2;
3551 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3552 }
3553 {
3554 PyThreadState* __tstate = wxPyBeginAllowThreads();
3555 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3556
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 {
3561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 wxSize *arg1 = (wxSize *) 0 ;
3572 wxSize *arg2 = 0 ;
3573 bool result;
3574 wxSize temp2 ;
3575 PyObject * obj0 = 0 ;
3576 PyObject * obj1 = 0 ;
3577 char *kwnames[] = {
3578 (char *) "self",(char *) "sz", NULL
3579 };
3580
3581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3583 if (SWIG_arg_fail(1)) SWIG_fail;
3584 {
3585 arg2 = &temp2;
3586 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3587 }
3588 {
3589 PyThreadState* __tstate = wxPyBeginAllowThreads();
3590 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3591
3592 wxPyEndAllowThreads(__tstate);
3593 if (PyErr_Occurred()) SWIG_fail;
3594 }
3595 {
3596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3597 }
3598 return resultobj;
3599 fail:
3600 return NULL;
3601 }
3602
3603
3604 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3605 PyObject *resultobj;
3606 wxSize *arg1 = (wxSize *) 0 ;
3607 wxSize *arg2 = 0 ;
3608 wxSize result;
3609 wxSize temp2 ;
3610 PyObject * obj0 = 0 ;
3611 PyObject * obj1 = 0 ;
3612 char *kwnames[] = {
3613 (char *) "self",(char *) "sz", NULL
3614 };
3615
3616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3618 if (SWIG_arg_fail(1)) SWIG_fail;
3619 {
3620 arg2 = &temp2;
3621 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3622 }
3623 {
3624 PyThreadState* __tstate = wxPyBeginAllowThreads();
3625 result = (arg1)->operator +((wxSize const &)*arg2);
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 {
3631 wxSize * resultptr;
3632 resultptr = new wxSize((wxSize &)(result));
3633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3634 }
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3642 PyObject *resultobj;
3643 wxSize *arg1 = (wxSize *) 0 ;
3644 wxSize *arg2 = 0 ;
3645 wxSize result;
3646 wxSize temp2 ;
3647 PyObject * obj0 = 0 ;
3648 PyObject * obj1 = 0 ;
3649 char *kwnames[] = {
3650 (char *) "self",(char *) "sz", NULL
3651 };
3652
3653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3655 if (SWIG_arg_fail(1)) SWIG_fail;
3656 {
3657 arg2 = &temp2;
3658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3659 }
3660 {
3661 PyThreadState* __tstate = wxPyBeginAllowThreads();
3662 result = (arg1)->operator -((wxSize const &)*arg2);
3663
3664 wxPyEndAllowThreads(__tstate);
3665 if (PyErr_Occurred()) SWIG_fail;
3666 }
3667 {
3668 wxSize * resultptr;
3669 resultptr = new wxSize((wxSize &)(result));
3670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3671 }
3672 return resultobj;
3673 fail:
3674 return NULL;
3675 }
3676
3677
3678 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3679 PyObject *resultobj;
3680 wxSize *arg1 = (wxSize *) 0 ;
3681 wxSize *arg2 = 0 ;
3682 wxSize temp2 ;
3683 PyObject * obj0 = 0 ;
3684 PyObject * obj1 = 0 ;
3685 char *kwnames[] = {
3686 (char *) "self",(char *) "sz", NULL
3687 };
3688
3689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3691 if (SWIG_arg_fail(1)) SWIG_fail;
3692 {
3693 arg2 = &temp2;
3694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3695 }
3696 {
3697 PyThreadState* __tstate = wxPyBeginAllowThreads();
3698 (arg1)->IncTo((wxSize const &)*arg2);
3699
3700 wxPyEndAllowThreads(__tstate);
3701 if (PyErr_Occurred()) SWIG_fail;
3702 }
3703 Py_INCREF(Py_None); resultobj = Py_None;
3704 return resultobj;
3705 fail:
3706 return NULL;
3707 }
3708
3709
3710 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3711 PyObject *resultobj;
3712 wxSize *arg1 = (wxSize *) 0 ;
3713 wxSize *arg2 = 0 ;
3714 wxSize temp2 ;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "self",(char *) "sz", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 {
3725 arg2 = &temp2;
3726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3727 }
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 (arg1)->DecTo((wxSize const &)*arg2);
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 Py_INCREF(Py_None); resultobj = Py_None;
3736 return resultobj;
3737 fail:
3738 return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3743 PyObject *resultobj;
3744 wxSize *arg1 = (wxSize *) 0 ;
3745 int arg2 ;
3746 int arg3 ;
3747 PyObject * obj0 = 0 ;
3748 PyObject * obj1 = 0 ;
3749 PyObject * obj2 = 0 ;
3750 char *kwnames[] = {
3751 (char *) "self",(char *) "w",(char *) "h", NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3756 if (SWIG_arg_fail(1)) SWIG_fail;
3757 {
3758 arg2 = (int)(SWIG_As_int(obj1));
3759 if (SWIG_arg_fail(2)) SWIG_fail;
3760 }
3761 {
3762 arg3 = (int)(SWIG_As_int(obj2));
3763 if (SWIG_arg_fail(3)) SWIG_fail;
3764 }
3765 {
3766 PyThreadState* __tstate = wxPyBeginAllowThreads();
3767 (arg1)->Set(arg2,arg3);
3768
3769 wxPyEndAllowThreads(__tstate);
3770 if (PyErr_Occurred()) SWIG_fail;
3771 }
3772 Py_INCREF(Py_None); resultobj = Py_None;
3773 return resultobj;
3774 fail:
3775 return NULL;
3776 }
3777
3778
3779 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3780 PyObject *resultobj;
3781 wxSize *arg1 = (wxSize *) 0 ;
3782 int arg2 ;
3783 PyObject * obj0 = 0 ;
3784 PyObject * obj1 = 0 ;
3785 char *kwnames[] = {
3786 (char *) "self",(char *) "w", NULL
3787 };
3788
3789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3791 if (SWIG_arg_fail(1)) SWIG_fail;
3792 {
3793 arg2 = (int)(SWIG_As_int(obj1));
3794 if (SWIG_arg_fail(2)) SWIG_fail;
3795 }
3796 {
3797 PyThreadState* __tstate = wxPyBeginAllowThreads();
3798 (arg1)->SetWidth(arg2);
3799
3800 wxPyEndAllowThreads(__tstate);
3801 if (PyErr_Occurred()) SWIG_fail;
3802 }
3803 Py_INCREF(Py_None); resultobj = Py_None;
3804 return resultobj;
3805 fail:
3806 return NULL;
3807 }
3808
3809
3810 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3811 PyObject *resultobj;
3812 wxSize *arg1 = (wxSize *) 0 ;
3813 int arg2 ;
3814 PyObject * obj0 = 0 ;
3815 PyObject * obj1 = 0 ;
3816 char *kwnames[] = {
3817 (char *) "self",(char *) "h", NULL
3818 };
3819
3820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3822 if (SWIG_arg_fail(1)) SWIG_fail;
3823 {
3824 arg2 = (int)(SWIG_As_int(obj1));
3825 if (SWIG_arg_fail(2)) SWIG_fail;
3826 }
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 (arg1)->SetHeight(arg2);
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 Py_INCREF(Py_None); resultobj = Py_None;
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 int result;
3845 PyObject * obj0 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = (int)((wxSize const *)arg1)->GetWidth();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 resultobj = SWIG_From_int((int)(result));
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxSize *arg1 = (wxSize *) 0 ;
3872 int result;
3873 PyObject * obj0 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (int)((wxSize const *)arg1)->GetHeight();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = SWIG_From_int((int)(result));
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxSize *arg1 = (wxSize *) 0 ;
3900 bool result;
3901 PyObject * obj0 = 0 ;
3902 char *kwnames[] = {
3903 (char *) "self", NULL
3904 };
3905
3906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3908 if (SWIG_arg_fail(1)) SWIG_fail;
3909 {
3910 PyThreadState* __tstate = wxPyBeginAllowThreads();
3911 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3912
3913 wxPyEndAllowThreads(__tstate);
3914 if (PyErr_Occurred()) SWIG_fail;
3915 }
3916 {
3917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3918 }
3919 return resultobj;
3920 fail:
3921 return NULL;
3922 }
3923
3924
3925 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3926 PyObject *resultobj;
3927 wxSize *arg1 = (wxSize *) 0 ;
3928 wxSize *arg2 = 0 ;
3929 wxSize temp2 ;
3930 PyObject * obj0 = 0 ;
3931 PyObject * obj1 = 0 ;
3932 char *kwnames[] = {
3933 (char *) "self",(char *) "size", NULL
3934 };
3935
3936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3938 if (SWIG_arg_fail(1)) SWIG_fail;
3939 {
3940 arg2 = &temp2;
3941 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3942 }
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 (arg1)->SetDefaults((wxSize const &)*arg2);
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 Py_INCREF(Py_None); resultobj = Py_None;
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj;
3959 wxSize *arg1 = (wxSize *) 0 ;
3960 PyObject *result;
3961 PyObject * obj0 = 0 ;
3962 char *kwnames[] = {
3963 (char *) "self", NULL
3964 };
3965
3966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3968 if (SWIG_arg_fail(1)) SWIG_fail;
3969 {
3970 PyThreadState* __tstate = wxPyBeginAllowThreads();
3971 result = (PyObject *)wxSize_Get(arg1);
3972
3973 wxPyEndAllowThreads(__tstate);
3974 if (PyErr_Occurred()) SWIG_fail;
3975 }
3976 resultobj = result;
3977 return resultobj;
3978 fail:
3979 return NULL;
3980 }
3981
3982
3983 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3984 PyObject *obj;
3985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3986 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3987 Py_INCREF(obj);
3988 return Py_BuildValue((char *)"");
3989 }
3990 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3993 double arg2 ;
3994 PyObject * obj0 = 0 ;
3995 PyObject * obj1 = 0 ;
3996 char *kwnames[] = {
3997 (char *) "self",(char *) "x", NULL
3998 };
3999
4000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4002 if (SWIG_arg_fail(1)) SWIG_fail;
4003 {
4004 arg2 = (double)(SWIG_As_double(obj1));
4005 if (SWIG_arg_fail(2)) SWIG_fail;
4006 }
4007 if (arg1) (arg1)->x = arg2;
4008
4009 Py_INCREF(Py_None); resultobj = Py_None;
4010 return resultobj;
4011 fail:
4012 return NULL;
4013 }
4014
4015
4016 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4017 PyObject *resultobj;
4018 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4019 double result;
4020 PyObject * obj0 = 0 ;
4021 char *kwnames[] = {
4022 (char *) "self", NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4027 if (SWIG_arg_fail(1)) SWIG_fail;
4028 result = (double) ((arg1)->x);
4029
4030 {
4031 resultobj = SWIG_From_double((double)(result));
4032 }
4033 return resultobj;
4034 fail:
4035 return NULL;
4036 }
4037
4038
4039 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4040 PyObject *resultobj;
4041 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4042 double arg2 ;
4043 PyObject * obj0 = 0 ;
4044 PyObject * obj1 = 0 ;
4045 char *kwnames[] = {
4046 (char *) "self",(char *) "y", NULL
4047 };
4048
4049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4051 if (SWIG_arg_fail(1)) SWIG_fail;
4052 {
4053 arg2 = (double)(SWIG_As_double(obj1));
4054 if (SWIG_arg_fail(2)) SWIG_fail;
4055 }
4056 if (arg1) (arg1)->y = arg2;
4057
4058 Py_INCREF(Py_None); resultobj = Py_None;
4059 return resultobj;
4060 fail:
4061 return NULL;
4062 }
4063
4064
4065 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4066 PyObject *resultobj;
4067 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4068 double result;
4069 PyObject * obj0 = 0 ;
4070 char *kwnames[] = {
4071 (char *) "self", NULL
4072 };
4073
4074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4076 if (SWIG_arg_fail(1)) SWIG_fail;
4077 result = (double) ((arg1)->y);
4078
4079 {
4080 resultobj = SWIG_From_double((double)(result));
4081 }
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 double arg1 = (double) 0.0 ;
4091 double arg2 = (double) 0.0 ;
4092 wxRealPoint *result;
4093 PyObject * obj0 = 0 ;
4094 PyObject * obj1 = 0 ;
4095 char *kwnames[] = {
4096 (char *) "x",(char *) "y", NULL
4097 };
4098
4099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4100 if (obj0) {
4101 {
4102 arg1 = (double)(SWIG_As_double(obj0));
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 }
4105 }
4106 if (obj1) {
4107 {
4108 arg2 = (double)(SWIG_As_double(obj1));
4109 if (SWIG_arg_fail(2)) SWIG_fail;
4110 }
4111 }
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj;
4128 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4129 PyObject * obj0 = 0 ;
4130 char *kwnames[] = {
4131 (char *) "self", NULL
4132 };
4133
4134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4136 if (SWIG_arg_fail(1)) SWIG_fail;
4137 {
4138 PyThreadState* __tstate = wxPyBeginAllowThreads();
4139 delete arg1;
4140
4141 wxPyEndAllowThreads(__tstate);
4142 if (PyErr_Occurred()) SWIG_fail;
4143 }
4144 Py_INCREF(Py_None); resultobj = Py_None;
4145 return resultobj;
4146 fail:
4147 return NULL;
4148 }
4149
4150
4151 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4152 PyObject *resultobj;
4153 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4154 wxRealPoint *arg2 = 0 ;
4155 bool result;
4156 wxRealPoint temp2 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "self",(char *) "pt", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4165 if (SWIG_arg_fail(1)) SWIG_fail;
4166 {
4167 arg2 = &temp2;
4168 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4179 }
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4189 wxRealPoint *arg2 = 0 ;
4190 bool result;
4191 wxRealPoint temp2 ;
4192 PyObject * obj0 = 0 ;
4193 PyObject * obj1 = 0 ;
4194 char *kwnames[] = {
4195 (char *) "self",(char *) "pt", NULL
4196 };
4197
4198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4200 if (SWIG_arg_fail(1)) SWIG_fail;
4201 {
4202 arg2 = &temp2;
4203 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4204 }
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4214 }
4215 return resultobj;
4216 fail:
4217 return NULL;
4218 }
4219
4220
4221 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4222 PyObject *resultobj;
4223 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4224 wxRealPoint *arg2 = 0 ;
4225 wxRealPoint result;
4226 wxRealPoint temp2 ;
4227 PyObject * obj0 = 0 ;
4228 PyObject * obj1 = 0 ;
4229 char *kwnames[] = {
4230 (char *) "self",(char *) "pt", NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4235 if (SWIG_arg_fail(1)) SWIG_fail;
4236 {
4237 arg2 = &temp2;
4238 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4239 }
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 {
4248 wxRealPoint * resultptr;
4249 resultptr = new wxRealPoint((wxRealPoint &)(result));
4250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4251 }
4252 return resultobj;
4253 fail:
4254 return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4259 PyObject *resultobj;
4260 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4261 wxRealPoint *arg2 = 0 ;
4262 wxRealPoint result;
4263 wxRealPoint temp2 ;
4264 PyObject * obj0 = 0 ;
4265 PyObject * obj1 = 0 ;
4266 char *kwnames[] = {
4267 (char *) "self",(char *) "pt", NULL
4268 };
4269
4270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4272 if (SWIG_arg_fail(1)) SWIG_fail;
4273 {
4274 arg2 = &temp2;
4275 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4276 }
4277 {
4278 PyThreadState* __tstate = wxPyBeginAllowThreads();
4279 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4280
4281 wxPyEndAllowThreads(__tstate);
4282 if (PyErr_Occurred()) SWIG_fail;
4283 }
4284 {
4285 wxRealPoint * resultptr;
4286 resultptr = new wxRealPoint((wxRealPoint &)(result));
4287 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4288 }
4289 return resultobj;
4290 fail:
4291 return NULL;
4292 }
4293
4294
4295 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj;
4297 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4298 double arg2 ;
4299 double arg3 ;
4300 PyObject * obj0 = 0 ;
4301 PyObject * obj1 = 0 ;
4302 PyObject * obj2 = 0 ;
4303 char *kwnames[] = {
4304 (char *) "self",(char *) "x",(char *) "y", NULL
4305 };
4306
4307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4309 if (SWIG_arg_fail(1)) SWIG_fail;
4310 {
4311 arg2 = (double)(SWIG_As_double(obj1));
4312 if (SWIG_arg_fail(2)) SWIG_fail;
4313 }
4314 {
4315 arg3 = (double)(SWIG_As_double(obj2));
4316 if (SWIG_arg_fail(3)) SWIG_fail;
4317 }
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 wxRealPoint_Set(arg1,arg2,arg3);
4321
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 Py_INCREF(Py_None); resultobj = Py_None;
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj;
4334 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4335 PyObject *result;
4336 PyObject * obj0 = 0 ;
4337 char *kwnames[] = {
4338 (char *) "self", NULL
4339 };
4340
4341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4343 if (SWIG_arg_fail(1)) SWIG_fail;
4344 {
4345 PyThreadState* __tstate = wxPyBeginAllowThreads();
4346 result = (PyObject *)wxRealPoint_Get(arg1);
4347
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 resultobj = result;
4352 return resultobj;
4353 fail:
4354 return NULL;
4355 }
4356
4357
4358 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4359 PyObject *obj;
4360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4361 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4362 Py_INCREF(obj);
4363 return Py_BuildValue((char *)"");
4364 }
4365 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxPoint *arg1 = (wxPoint *) 0 ;
4368 int arg2 ;
4369 PyObject * obj0 = 0 ;
4370 PyObject * obj1 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self",(char *) "x", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4377 if (SWIG_arg_fail(1)) SWIG_fail;
4378 {
4379 arg2 = (int)(SWIG_As_int(obj1));
4380 if (SWIG_arg_fail(2)) SWIG_fail;
4381 }
4382 if (arg1) (arg1)->x = arg2;
4383
4384 Py_INCREF(Py_None); resultobj = Py_None;
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 wxPoint *arg1 = (wxPoint *) 0 ;
4394 int result;
4395 PyObject * obj0 = 0 ;
4396 char *kwnames[] = {
4397 (char *) "self", NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4402 if (SWIG_arg_fail(1)) SWIG_fail;
4403 result = (int) ((arg1)->x);
4404
4405 {
4406 resultobj = SWIG_From_int((int)(result));
4407 }
4408 return resultobj;
4409 fail:
4410 return NULL;
4411 }
4412
4413
4414 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj;
4416 wxPoint *arg1 = (wxPoint *) 0 ;
4417 int arg2 ;
4418 PyObject * obj0 = 0 ;
4419 PyObject * obj1 = 0 ;
4420 char *kwnames[] = {
4421 (char *) "self",(char *) "y", NULL
4422 };
4423
4424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4426 if (SWIG_arg_fail(1)) SWIG_fail;
4427 {
4428 arg2 = (int)(SWIG_As_int(obj1));
4429 if (SWIG_arg_fail(2)) SWIG_fail;
4430 }
4431 if (arg1) (arg1)->y = arg2;
4432
4433 Py_INCREF(Py_None); resultobj = Py_None;
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj;
4442 wxPoint *arg1 = (wxPoint *) 0 ;
4443 int result;
4444 PyObject * obj0 = 0 ;
4445 char *kwnames[] = {
4446 (char *) "self", NULL
4447 };
4448
4449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4451 if (SWIG_arg_fail(1)) SWIG_fail;
4452 result = (int) ((arg1)->y);
4453
4454 {
4455 resultobj = SWIG_From_int((int)(result));
4456 }
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj;
4465 int arg1 = (int) 0 ;
4466 int arg2 = (int) 0 ;
4467 wxPoint *result;
4468 PyObject * obj0 = 0 ;
4469 PyObject * obj1 = 0 ;
4470 char *kwnames[] = {
4471 (char *) "x",(char *) "y", NULL
4472 };
4473
4474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4475 if (obj0) {
4476 {
4477 arg1 = (int)(SWIG_As_int(obj0));
4478 if (SWIG_arg_fail(1)) SWIG_fail;
4479 }
4480 }
4481 if (obj1) {
4482 {
4483 arg2 = (int)(SWIG_As_int(obj1));
4484 if (SWIG_arg_fail(2)) SWIG_fail;
4485 }
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (wxPoint *)new wxPoint(arg1,arg2);
4490
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4495 return resultobj;
4496 fail:
4497 return NULL;
4498 }
4499
4500
4501 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4502 PyObject *resultobj;
4503 wxPoint *arg1 = (wxPoint *) 0 ;
4504 PyObject * obj0 = 0 ;
4505 char *kwnames[] = {
4506 (char *) "self", NULL
4507 };
4508
4509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4511 if (SWIG_arg_fail(1)) SWIG_fail;
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 delete arg1;
4515
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 Py_INCREF(Py_None); resultobj = Py_None;
4520 return resultobj;
4521 fail:
4522 return NULL;
4523 }
4524
4525
4526 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4527 PyObject *resultobj;
4528 wxPoint *arg1 = (wxPoint *) 0 ;
4529 wxPoint *arg2 = 0 ;
4530 bool result;
4531 wxPoint temp2 ;
4532 PyObject * obj0 = 0 ;
4533 PyObject * obj1 = 0 ;
4534 char *kwnames[] = {
4535 (char *) "self",(char *) "pt", NULL
4536 };
4537
4538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4540 if (SWIG_arg_fail(1)) SWIG_fail;
4541 {
4542 arg2 = &temp2;
4543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4544 }
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4548
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj;
4563 wxPoint *arg1 = (wxPoint *) 0 ;
4564 wxPoint *arg2 = 0 ;
4565 bool result;
4566 wxPoint temp2 ;
4567 PyObject * obj0 = 0 ;
4568 PyObject * obj1 = 0 ;
4569 char *kwnames[] = {
4570 (char *) "self",(char *) "pt", NULL
4571 };
4572
4573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4575 if (SWIG_arg_fail(1)) SWIG_fail;
4576 {
4577 arg2 = &temp2;
4578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4579 }
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4583
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 {
4588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4589 }
4590 return resultobj;
4591 fail:
4592 return NULL;
4593 }
4594
4595
4596 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4597 PyObject *resultobj;
4598 wxPoint *arg1 = (wxPoint *) 0 ;
4599 wxPoint *arg2 = 0 ;
4600 wxPoint result;
4601 wxPoint temp2 ;
4602 PyObject * obj0 = 0 ;
4603 PyObject * obj1 = 0 ;
4604 char *kwnames[] = {
4605 (char *) "self",(char *) "pt", NULL
4606 };
4607
4608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4610 if (SWIG_arg_fail(1)) SWIG_fail;
4611 {
4612 arg2 = &temp2;
4613 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4614 }
4615 {
4616 PyThreadState* __tstate = wxPyBeginAllowThreads();
4617 result = (arg1)->operator +((wxPoint const &)*arg2);
4618
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 {
4623 wxPoint * resultptr;
4624 resultptr = new wxPoint((wxPoint &)(result));
4625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4626 }
4627 return resultobj;
4628 fail:
4629 return NULL;
4630 }
4631
4632
4633 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4634 PyObject *resultobj;
4635 wxPoint *arg1 = (wxPoint *) 0 ;
4636 wxPoint *arg2 = 0 ;
4637 wxPoint result;
4638 wxPoint temp2 ;
4639 PyObject * obj0 = 0 ;
4640 PyObject * obj1 = 0 ;
4641 char *kwnames[] = {
4642 (char *) "self",(char *) "pt", NULL
4643 };
4644
4645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4647 if (SWIG_arg_fail(1)) SWIG_fail;
4648 {
4649 arg2 = &temp2;
4650 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4651 }
4652 {
4653 PyThreadState* __tstate = wxPyBeginAllowThreads();
4654 result = (arg1)->operator -((wxPoint const &)*arg2);
4655
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 {
4660 wxPoint * resultptr;
4661 resultptr = new wxPoint((wxPoint &)(result));
4662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4663 }
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxPoint *arg1 = (wxPoint *) 0 ;
4673 wxPoint *arg2 = 0 ;
4674 wxPoint *result;
4675 wxPoint temp2 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 char *kwnames[] = {
4679 (char *) "self",(char *) "pt", NULL
4680 };
4681
4682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4684 if (SWIG_arg_fail(1)) SWIG_fail;
4685 {
4686 arg2 = &temp2;
4687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4688 }
4689 {
4690 PyThreadState* __tstate = wxPyBeginAllowThreads();
4691 {
4692 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4693 result = (wxPoint *) &_result_ref;
4694 }
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj;
4708 wxPoint *arg1 = (wxPoint *) 0 ;
4709 wxPoint *arg2 = 0 ;
4710 wxPoint *result;
4711 wxPoint temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self",(char *) "pt", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 arg2 = &temp2;
4723 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4724 }
4725 {
4726 PyThreadState* __tstate = wxPyBeginAllowThreads();
4727 {
4728 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4729 result = (wxPoint *) &_result_ref;
4730 }
4731
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj;
4744 wxPoint *arg1 = (wxPoint *) 0 ;
4745 long arg2 ;
4746 long arg3 ;
4747 PyObject * obj0 = 0 ;
4748 PyObject * obj1 = 0 ;
4749 PyObject * obj2 = 0 ;
4750 char *kwnames[] = {
4751 (char *) "self",(char *) "x",(char *) "y", NULL
4752 };
4753
4754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4756 if (SWIG_arg_fail(1)) SWIG_fail;
4757 {
4758 arg2 = (long)(SWIG_As_long(obj1));
4759 if (SWIG_arg_fail(2)) SWIG_fail;
4760 }
4761 {
4762 arg3 = (long)(SWIG_As_long(obj2));
4763 if (SWIG_arg_fail(3)) SWIG_fail;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 wxPoint_Set(arg1,arg2,arg3);
4768
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 Py_INCREF(Py_None); resultobj = Py_None;
4773 return resultobj;
4774 fail:
4775 return NULL;
4776 }
4777
4778
4779 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj;
4781 wxPoint *arg1 = (wxPoint *) 0 ;
4782 PyObject *result;
4783 PyObject * obj0 = 0 ;
4784 char *kwnames[] = {
4785 (char *) "self", NULL
4786 };
4787
4788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4790 if (SWIG_arg_fail(1)) SWIG_fail;
4791 {
4792 PyThreadState* __tstate = wxPyBeginAllowThreads();
4793 result = (PyObject *)wxPoint_Get(arg1);
4794
4795 wxPyEndAllowThreads(__tstate);
4796 if (PyErr_Occurred()) SWIG_fail;
4797 }
4798 resultobj = result;
4799 return resultobj;
4800 fail:
4801 return NULL;
4802 }
4803
4804
4805 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4806 PyObject *obj;
4807 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4808 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4809 Py_INCREF(obj);
4810 return Py_BuildValue((char *)"");
4811 }
4812 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4813 PyObject *resultobj;
4814 int arg1 = (int) 0 ;
4815 int arg2 = (int) 0 ;
4816 int arg3 = (int) 0 ;
4817 int arg4 = (int) 0 ;
4818 wxRect *result;
4819 PyObject * obj0 = 0 ;
4820 PyObject * obj1 = 0 ;
4821 PyObject * obj2 = 0 ;
4822 PyObject * obj3 = 0 ;
4823 char *kwnames[] = {
4824 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4825 };
4826
4827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4828 if (obj0) {
4829 {
4830 arg1 = (int)(SWIG_As_int(obj0));
4831 if (SWIG_arg_fail(1)) SWIG_fail;
4832 }
4833 }
4834 if (obj1) {
4835 {
4836 arg2 = (int)(SWIG_As_int(obj1));
4837 if (SWIG_arg_fail(2)) SWIG_fail;
4838 }
4839 }
4840 if (obj2) {
4841 {
4842 arg3 = (int)(SWIG_As_int(obj2));
4843 if (SWIG_arg_fail(3)) SWIG_fail;
4844 }
4845 }
4846 if (obj3) {
4847 {
4848 arg4 = (int)(SWIG_As_int(obj3));
4849 if (SWIG_arg_fail(4)) SWIG_fail;
4850 }
4851 }
4852 {
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4855
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxPoint *arg1 = 0 ;
4869 wxPoint *arg2 = 0 ;
4870 wxRect *result;
4871 wxPoint temp1 ;
4872 wxPoint temp2 ;
4873 PyObject * obj0 = 0 ;
4874 PyObject * obj1 = 0 ;
4875 char *kwnames[] = {
4876 (char *) "topLeft",(char *) "bottomRight", NULL
4877 };
4878
4879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4880 {
4881 arg1 = &temp1;
4882 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4883 }
4884 {
4885 arg2 = &temp2;
4886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4887 }
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4891
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj;
4904 wxPoint *arg1 = 0 ;
4905 wxSize *arg2 = 0 ;
4906 wxRect *result;
4907 wxPoint temp1 ;
4908 wxSize temp2 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "pos",(char *) "size", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4916 {
4917 arg1 = &temp1;
4918 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4919 }
4920 {
4921 arg2 = &temp2;
4922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4923 }
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4932 return resultobj;
4933 fail:
4934 return NULL;
4935 }
4936
4937
4938 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4939 PyObject *resultobj;
4940 wxSize *arg1 = 0 ;
4941 wxRect *result;
4942 wxSize temp1 ;
4943 PyObject * obj0 = 0 ;
4944 char *kwnames[] = {
4945 (char *) "size", NULL
4946 };
4947
4948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4949 {
4950 arg1 = &temp1;
4951 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4956
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxRect *arg1 = (wxRect *) 0 ;
4970 PyObject * obj0 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "self", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(1)) SWIG_fail;
4978 {
4979 PyThreadState* __tstate = wxPyBeginAllowThreads();
4980 delete arg1;
4981
4982 wxPyEndAllowThreads(__tstate);
4983 if (PyErr_Occurred()) SWIG_fail;
4984 }
4985 Py_INCREF(Py_None); resultobj = Py_None;
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj;
4994 wxRect *arg1 = (wxRect *) 0 ;
4995 int result;
4996 PyObject * obj0 = 0 ;
4997 char *kwnames[] = {
4998 (char *) "self", NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5003 if (SWIG_arg_fail(1)) SWIG_fail;
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = (int)((wxRect const *)arg1)->GetX();
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 {
5012 resultobj = SWIG_From_int((int)(result));
5013 }
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj;
5022 wxRect *arg1 = (wxRect *) 0 ;
5023 int arg2 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 char *kwnames[] = {
5027 (char *) "self",(char *) "x", NULL
5028 };
5029
5030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5032 if (SWIG_arg_fail(1)) SWIG_fail;
5033 {
5034 arg2 = (int)(SWIG_As_int(obj1));
5035 if (SWIG_arg_fail(2)) SWIG_fail;
5036 }
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 (arg1)->SetX(arg2);
5040
5041 wxPyEndAllowThreads(__tstate);
5042 if (PyErr_Occurred()) SWIG_fail;
5043 }
5044 Py_INCREF(Py_None); resultobj = Py_None;
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxRect *arg1 = (wxRect *) 0 ;
5054 int result;
5055 PyObject * obj0 = 0 ;
5056 char *kwnames[] = {
5057 (char *) "self", NULL
5058 };
5059
5060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5062 if (SWIG_arg_fail(1)) SWIG_fail;
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (int)(arg1)->GetY();
5066
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 {
5071 resultobj = SWIG_From_int((int)(result));
5072 }
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5080 PyObject *resultobj;
5081 wxRect *arg1 = (wxRect *) 0 ;
5082 int arg2 ;
5083 PyObject * obj0 = 0 ;
5084 PyObject * obj1 = 0 ;
5085 char *kwnames[] = {
5086 (char *) "self",(char *) "y", NULL
5087 };
5088
5089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5091 if (SWIG_arg_fail(1)) SWIG_fail;
5092 {
5093 arg2 = (int)(SWIG_As_int(obj1));
5094 if (SWIG_arg_fail(2)) SWIG_fail;
5095 }
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 (arg1)->SetY(arg2);
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 Py_INCREF(Py_None); resultobj = Py_None;
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int result;
5114 PyObject * obj0 = 0 ;
5115 char *kwnames[] = {
5116 (char *) "self", NULL
5117 };
5118
5119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5121 if (SWIG_arg_fail(1)) SWIG_fail;
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (int)((wxRect const *)arg1)->GetWidth();
5125
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 {
5130 resultobj = SWIG_From_int((int)(result));
5131 }
5132 return resultobj;
5133 fail:
5134 return NULL;
5135 }
5136
5137
5138 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5139 PyObject *resultobj;
5140 wxRect *arg1 = (wxRect *) 0 ;
5141 int arg2 ;
5142 PyObject * obj0 = 0 ;
5143 PyObject * obj1 = 0 ;
5144 char *kwnames[] = {
5145 (char *) "self",(char *) "w", NULL
5146 };
5147
5148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5150 if (SWIG_arg_fail(1)) SWIG_fail;
5151 {
5152 arg2 = (int)(SWIG_As_int(obj1));
5153 if (SWIG_arg_fail(2)) SWIG_fail;
5154 }
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 (arg1)->SetWidth(arg2);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 Py_INCREF(Py_None); resultobj = Py_None;
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int result;
5173 PyObject * obj0 = 0 ;
5174 char *kwnames[] = {
5175 (char *) "self", NULL
5176 };
5177
5178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5180 if (SWIG_arg_fail(1)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (int)((wxRect const *)arg1)->GetHeight();
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 {
5189 resultobj = SWIG_From_int((int)(result));
5190 }
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj;
5199 wxRect *arg1 = (wxRect *) 0 ;
5200 int arg2 ;
5201 PyObject * obj0 = 0 ;
5202 PyObject * obj1 = 0 ;
5203 char *kwnames[] = {
5204 (char *) "self",(char *) "h", NULL
5205 };
5206
5207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5209 if (SWIG_arg_fail(1)) SWIG_fail;
5210 {
5211 arg2 = (int)(SWIG_As_int(obj1));
5212 if (SWIG_arg_fail(2)) SWIG_fail;
5213 }
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 (arg1)->SetHeight(arg2);
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 Py_INCREF(Py_None); resultobj = Py_None;
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj;
5230 wxRect *arg1 = (wxRect *) 0 ;
5231 wxPoint result;
5232 PyObject * obj0 = 0 ;
5233 char *kwnames[] = {
5234 (char *) "self", NULL
5235 };
5236
5237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5239 if (SWIG_arg_fail(1)) SWIG_fail;
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 result = ((wxRect const *)arg1)->GetPosition();
5243
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 {
5248 wxPoint * resultptr;
5249 resultptr = new wxPoint((wxPoint &)(result));
5250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5251 }
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj;
5260 wxRect *arg1 = (wxRect *) 0 ;
5261 wxPoint *arg2 = 0 ;
5262 wxPoint temp2 ;
5263 PyObject * obj0 = 0 ;
5264 PyObject * obj1 = 0 ;
5265 char *kwnames[] = {
5266 (char *) "self",(char *) "p", NULL
5267 };
5268
5269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5271 if (SWIG_arg_fail(1)) SWIG_fail;
5272 {
5273 arg2 = &temp2;
5274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5275 }
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 (arg1)->SetPosition((wxPoint const &)*arg2);
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 Py_INCREF(Py_None); resultobj = Py_None;
5284 return resultobj;
5285 fail:
5286 return NULL;
5287 }
5288
5289
5290 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5291 PyObject *resultobj;
5292 wxRect *arg1 = (wxRect *) 0 ;
5293 wxSize result;
5294 PyObject * obj0 = 0 ;
5295 char *kwnames[] = {
5296 (char *) "self", NULL
5297 };
5298
5299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5301 if (SWIG_arg_fail(1)) SWIG_fail;
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 result = ((wxRect const *)arg1)->GetSize();
5305
5306 wxPyEndAllowThreads(__tstate);
5307 if (PyErr_Occurred()) SWIG_fail;
5308 }
5309 {
5310 wxSize * resultptr;
5311 resultptr = new wxSize((wxSize &)(result));
5312 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5313 }
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj;
5322 wxRect *arg1 = (wxRect *) 0 ;
5323 wxSize *arg2 = 0 ;
5324 wxSize temp2 ;
5325 PyObject * obj0 = 0 ;
5326 PyObject * obj1 = 0 ;
5327 char *kwnames[] = {
5328 (char *) "self",(char *) "s", NULL
5329 };
5330
5331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5333 if (SWIG_arg_fail(1)) SWIG_fail;
5334 {
5335 arg2 = &temp2;
5336 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5337 }
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 (arg1)->SetSize((wxSize const &)*arg2);
5341
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 Py_INCREF(Py_None); resultobj = Py_None;
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj;
5354 wxRect *arg1 = (wxRect *) 0 ;
5355 bool result;
5356 PyObject * obj0 = 0 ;
5357 char *kwnames[] = {
5358 (char *) "self", NULL
5359 };
5360
5361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5363 if (SWIG_arg_fail(1)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = (bool)((wxRect const *)arg1)->IsEmpty();
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5373 }
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5381 PyObject *resultobj;
5382 wxRect *arg1 = (wxRect *) 0 ;
5383 wxPoint result;
5384 PyObject * obj0 = 0 ;
5385 char *kwnames[] = {
5386 (char *) "self", NULL
5387 };
5388
5389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5391 if (SWIG_arg_fail(1)) SWIG_fail;
5392 {
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 result = ((wxRect const *)arg1)->GetTopLeft();
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 {
5400 wxPoint * resultptr;
5401 resultptr = new wxPoint((wxPoint &)(result));
5402 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj;
5412 wxRect *arg1 = (wxRect *) 0 ;
5413 wxPoint *arg2 = 0 ;
5414 wxPoint temp2 ;
5415 PyObject * obj0 = 0 ;
5416 PyObject * obj1 = 0 ;
5417 char *kwnames[] = {
5418 (char *) "self",(char *) "p", NULL
5419 };
5420
5421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5423 if (SWIG_arg_fail(1)) SWIG_fail;
5424 {
5425 arg2 = &temp2;
5426 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5427 }
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 Py_INCREF(Py_None); resultobj = Py_None;
5436 return resultobj;
5437 fail:
5438 return NULL;
5439 }
5440
5441
5442 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5443 PyObject *resultobj;
5444 wxRect *arg1 = (wxRect *) 0 ;
5445 wxPoint result;
5446 PyObject * obj0 = 0 ;
5447 char *kwnames[] = {
5448 (char *) "self", NULL
5449 };
5450
5451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5453 if (SWIG_arg_fail(1)) SWIG_fail;
5454 {
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 result = ((wxRect const *)arg1)->GetBottomRight();
5457
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 {
5462 wxPoint * resultptr;
5463 resultptr = new wxPoint((wxPoint &)(result));
5464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj;
5474 wxRect *arg1 = (wxRect *) 0 ;
5475 wxPoint *arg2 = 0 ;
5476 wxPoint temp2 ;
5477 PyObject * obj0 = 0 ;
5478 PyObject * obj1 = 0 ;
5479 char *kwnames[] = {
5480 (char *) "self",(char *) "p", NULL
5481 };
5482
5483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5485 if (SWIG_arg_fail(1)) SWIG_fail;
5486 {
5487 arg2 = &temp2;
5488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5489 }
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5493
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 Py_INCREF(Py_None); resultobj = Py_None;
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int result;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = (int)((wxRect const *)arg1)->GetLeft();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 resultobj = SWIG_From_int((int)(result));
5525 }
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj;
5534 wxRect *arg1 = (wxRect *) 0 ;
5535 int result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (int)((wxRect const *)arg1)->GetTop();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_int((int)(result));
5553 }
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj;
5562 wxRect *arg1 = (wxRect *) 0 ;
5563 int result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)((wxRect const *)arg1)->GetBottom();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxRect *arg1 = (wxRect *) 0 ;
5591 int result;
5592 PyObject * obj0 = 0 ;
5593 char *kwnames[] = {
5594 (char *) "self", NULL
5595 };
5596
5597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5599 if (SWIG_arg_fail(1)) SWIG_fail;
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 result = (int)((wxRect const *)arg1)->GetRight();
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 {
5608 resultobj = SWIG_From_int((int)(result));
5609 }
5610 return resultobj;
5611 fail:
5612 return NULL;
5613 }
5614
5615
5616 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5617 PyObject *resultobj;
5618 wxRect *arg1 = (wxRect *) 0 ;
5619 int arg2 ;
5620 PyObject * obj0 = 0 ;
5621 PyObject * obj1 = 0 ;
5622 char *kwnames[] = {
5623 (char *) "self",(char *) "left", NULL
5624 };
5625
5626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5628 if (SWIG_arg_fail(1)) SWIG_fail;
5629 {
5630 arg2 = (int)(SWIG_As_int(obj1));
5631 if (SWIG_arg_fail(2)) SWIG_fail;
5632 }
5633 {
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 (arg1)->SetLeft(arg2);
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 Py_INCREF(Py_None); resultobj = Py_None;
5641 return resultobj;
5642 fail:
5643 return NULL;
5644 }
5645
5646
5647 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5648 PyObject *resultobj;
5649 wxRect *arg1 = (wxRect *) 0 ;
5650 int arg2 ;
5651 PyObject * obj0 = 0 ;
5652 PyObject * obj1 = 0 ;
5653 char *kwnames[] = {
5654 (char *) "self",(char *) "right", NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5659 if (SWIG_arg_fail(1)) SWIG_fail;
5660 {
5661 arg2 = (int)(SWIG_As_int(obj1));
5662 if (SWIG_arg_fail(2)) SWIG_fail;
5663 }
5664 {
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 (arg1)->SetRight(arg2);
5667
5668 wxPyEndAllowThreads(__tstate);
5669 if (PyErr_Occurred()) SWIG_fail;
5670 }
5671 Py_INCREF(Py_None); resultobj = Py_None;
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj;
5680 wxRect *arg1 = (wxRect *) 0 ;
5681 int arg2 ;
5682 PyObject * obj0 = 0 ;
5683 PyObject * obj1 = 0 ;
5684 char *kwnames[] = {
5685 (char *) "self",(char *) "top", NULL
5686 };
5687
5688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5690 if (SWIG_arg_fail(1)) SWIG_fail;
5691 {
5692 arg2 = (int)(SWIG_As_int(obj1));
5693 if (SWIG_arg_fail(2)) SWIG_fail;
5694 }
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 (arg1)->SetTop(arg2);
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 Py_INCREF(Py_None); resultobj = Py_None;
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj;
5711 wxRect *arg1 = (wxRect *) 0 ;
5712 int arg2 ;
5713 PyObject * obj0 = 0 ;
5714 PyObject * obj1 = 0 ;
5715 char *kwnames[] = {
5716 (char *) "self",(char *) "bottom", NULL
5717 };
5718
5719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5721 if (SWIG_arg_fail(1)) SWIG_fail;
5722 {
5723 arg2 = (int)(SWIG_As_int(obj1));
5724 if (SWIG_arg_fail(2)) SWIG_fail;
5725 }
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 (arg1)->SetBottom(arg2);
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 Py_INCREF(Py_None); resultobj = Py_None;
5734 return resultobj;
5735 fail:
5736 return NULL;
5737 }
5738
5739
5740 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5741 PyObject *resultobj;
5742 wxRect *arg1 = (wxRect *) 0 ;
5743 int arg2 ;
5744 int arg3 ;
5745 wxRect *result;
5746 PyObject * obj0 = 0 ;
5747 PyObject * obj1 = 0 ;
5748 PyObject * obj2 = 0 ;
5749 char *kwnames[] = {
5750 (char *) "self",(char *) "dx",(char *) "dy", NULL
5751 };
5752
5753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5755 if (SWIG_arg_fail(1)) SWIG_fail;
5756 {
5757 arg2 = (int)(SWIG_As_int(obj1));
5758 if (SWIG_arg_fail(2)) SWIG_fail;
5759 }
5760 {
5761 arg3 = (int)(SWIG_As_int(obj2));
5762 if (SWIG_arg_fail(3)) SWIG_fail;
5763 }
5764 {
5765 PyThreadState* __tstate = wxPyBeginAllowThreads();
5766 {
5767 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5768 result = (wxRect *) &_result_ref;
5769 }
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 wxRect *arg1 = (wxRect *) 0 ;
5784 int arg2 ;
5785 int arg3 ;
5786 wxRect *result;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 PyObject * obj2 = 0 ;
5790 char *kwnames[] = {
5791 (char *) "self",(char *) "dx",(char *) "dy", NULL
5792 };
5793
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5796 if (SWIG_arg_fail(1)) SWIG_fail;
5797 {
5798 arg2 = (int)(SWIG_As_int(obj1));
5799 if (SWIG_arg_fail(2)) SWIG_fail;
5800 }
5801 {
5802 arg3 = (int)(SWIG_As_int(obj2));
5803 if (SWIG_arg_fail(3)) SWIG_fail;
5804 }
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 {
5808 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5809 result = (wxRect *) &_result_ref;
5810 }
5811
5812 wxPyEndAllowThreads(__tstate);
5813 if (PyErr_Occurred()) SWIG_fail;
5814 }
5815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5816 return resultobj;
5817 fail:
5818 return NULL;
5819 }
5820
5821
5822 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5823 PyObject *resultobj;
5824 wxRect *arg1 = (wxRect *) 0 ;
5825 int arg2 ;
5826 int arg3 ;
5827 PyObject * obj0 = 0 ;
5828 PyObject * obj1 = 0 ;
5829 PyObject * obj2 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "self",(char *) "dx",(char *) "dy", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5836 if (SWIG_arg_fail(1)) SWIG_fail;
5837 {
5838 arg2 = (int)(SWIG_As_int(obj1));
5839 if (SWIG_arg_fail(2)) SWIG_fail;
5840 }
5841 {
5842 arg3 = (int)(SWIG_As_int(obj2));
5843 if (SWIG_arg_fail(3)) SWIG_fail;
5844 }
5845 {
5846 PyThreadState* __tstate = wxPyBeginAllowThreads();
5847 (arg1)->Offset(arg2,arg3);
5848
5849 wxPyEndAllowThreads(__tstate);
5850 if (PyErr_Occurred()) SWIG_fail;
5851 }
5852 Py_INCREF(Py_None); resultobj = Py_None;
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj;
5861 wxRect *arg1 = (wxRect *) 0 ;
5862 wxPoint *arg2 = 0 ;
5863 wxPoint temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "pt", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 (arg1)->Offset((wxPoint const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 Py_INCREF(Py_None); resultobj = Py_None;
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj;
5893 wxRect *arg1 = (wxRect *) 0 ;
5894 wxRect *arg2 = 0 ;
5895 wxRect result;
5896 wxRect temp2 ;
5897 PyObject * obj0 = 0 ;
5898 PyObject * obj1 = 0 ;
5899 char *kwnames[] = {
5900 (char *) "self",(char *) "rect", NULL
5901 };
5902
5903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5905 if (SWIG_arg_fail(1)) SWIG_fail;
5906 {
5907 arg2 = &temp2;
5908 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5909 }
5910 {
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 result = (arg1)->Intersect((wxRect const &)*arg2);
5913
5914 wxPyEndAllowThreads(__tstate);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 {
5918 wxRect * resultptr;
5919 resultptr = new wxRect((wxRect &)(result));
5920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5921 }
5922 return resultobj;
5923 fail:
5924 return NULL;
5925 }
5926
5927
5928 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5929 PyObject *resultobj;
5930 wxRect *arg1 = (wxRect *) 0 ;
5931 wxRect *arg2 = 0 ;
5932 wxRect 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_Union",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 = (arg1)->Union((wxRect const &)*arg2);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 wxRect * resultptr;
5956 resultptr = new wxRect((wxRect &)(result));
5957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5958 }
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj;
5967 wxRect *arg1 = (wxRect *) 0 ;
5968 wxRect *arg2 = 0 ;
5969 wxRect result;
5970 wxRect temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "self",(char *) "rect", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5979 if (SWIG_arg_fail(1)) SWIG_fail;
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5987
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 {
5992 wxRect * resultptr;
5993 resultptr = new wxRect((wxRect &)(result));
5994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5995 }
5996 return resultobj;
5997 fail:
5998 return NULL;
5999 }
6000
6001
6002 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6003 PyObject *resultobj;
6004 wxRect *arg1 = (wxRect *) 0 ;
6005 wxRect *arg2 = 0 ;
6006 wxRect *result;
6007 wxRect temp2 ;
6008 PyObject * obj0 = 0 ;
6009 PyObject * obj1 = 0 ;
6010 char *kwnames[] = {
6011 (char *) "self",(char *) "rect", NULL
6012 };
6013
6014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6016 if (SWIG_arg_fail(1)) SWIG_fail;
6017 {
6018 arg2 = &temp2;
6019 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6020 }
6021 {
6022 PyThreadState* __tstate = wxPyBeginAllowThreads();
6023 {
6024 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6025 result = (wxRect *) &_result_ref;
6026 }
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 wxRect *arg1 = (wxRect *) 0 ;
6041 wxRect *arg2 = 0 ;
6042 bool result;
6043 wxRect temp2 ;
6044 PyObject * obj0 = 0 ;
6045 PyObject * obj1 = 0 ;
6046 char *kwnames[] = {
6047 (char *) "self",(char *) "rect", NULL
6048 };
6049
6050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",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 ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 PyThreadState* __tstate = wxPyBeginAllowThreads();
6059 result = (bool)((wxRect const *)arg1)->operator ==((wxRect 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___ne__(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___ne__",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)->operator !=((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_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6109 PyObject *resultobj;
6110 wxRect *arg1 = (wxRect *) 0 ;
6111 int arg2 ;
6112 int arg3 ;
6113 bool result;
6114 PyObject * obj0 = 0 ;
6115 PyObject * obj1 = 0 ;
6116 PyObject * obj2 = 0 ;
6117 char *kwnames[] = {
6118 (char *) "self",(char *) "x",(char *) "y", NULL
6119 };
6120
6121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6123 if (SWIG_arg_fail(1)) SWIG_fail;
6124 {
6125 arg2 = (int)(SWIG_As_int(obj1));
6126 if (SWIG_arg_fail(2)) SWIG_fail;
6127 }
6128 {
6129 arg3 = (int)(SWIG_As_int(obj2));
6130 if (SWIG_arg_fail(3)) SWIG_fail;
6131 }
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6141 }
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxRect *arg1 = (wxRect *) 0 ;
6151 wxPoint *arg2 = 0 ;
6152 bool result;
6153 wxPoint temp2 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 char *kwnames[] = {
6157 (char *) "self",(char *) "pt", NULL
6158 };
6159
6160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6162 if (SWIG_arg_fail(1)) SWIG_fail;
6163 {
6164 arg2 = &temp2;
6165 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6166 }
6167 {
6168 PyThreadState* __tstate = wxPyBeginAllowThreads();
6169 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6170
6171 wxPyEndAllowThreads(__tstate);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 {
6175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6176 }
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 wxRect *arg2 = 0 ;
6187 bool result;
6188 wxRect temp2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self",(char *) "rect", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 {
6199 arg2 = &temp2;
6200 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6201 }
6202 {
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6205
6206 wxPyEndAllowThreads(__tstate);
6207 if (PyErr_Occurred()) SWIG_fail;
6208 }
6209 {
6210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6211 }
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6219 PyObject *resultobj;
6220 wxRect *arg1 = (wxRect *) 0 ;
6221 int arg2 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 char *kwnames[] = {
6225 (char *) "self",(char *) "x", NULL
6226 };
6227
6228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6230 if (SWIG_arg_fail(1)) SWIG_fail;
6231 {
6232 arg2 = (int)(SWIG_As_int(obj1));
6233 if (SWIG_arg_fail(2)) SWIG_fail;
6234 }
6235 if (arg1) (arg1)->x = arg2;
6236
6237 Py_INCREF(Py_None); resultobj = Py_None;
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6245 PyObject *resultobj;
6246 wxRect *arg1 = (wxRect *) 0 ;
6247 int result;
6248 PyObject * obj0 = 0 ;
6249 char *kwnames[] = {
6250 (char *) "self", NULL
6251 };
6252
6253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6255 if (SWIG_arg_fail(1)) SWIG_fail;
6256 result = (int) ((arg1)->x);
6257
6258 {
6259 resultobj = SWIG_From_int((int)(result));
6260 }
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxRect *arg1 = (wxRect *) 0 ;
6270 int arg2 ;
6271 PyObject * obj0 = 0 ;
6272 PyObject * obj1 = 0 ;
6273 char *kwnames[] = {
6274 (char *) "self",(char *) "y", NULL
6275 };
6276
6277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6279 if (SWIG_arg_fail(1)) SWIG_fail;
6280 {
6281 arg2 = (int)(SWIG_As_int(obj1));
6282 if (SWIG_arg_fail(2)) SWIG_fail;
6283 }
6284 if (arg1) (arg1)->y = arg2;
6285
6286 Py_INCREF(Py_None); resultobj = Py_None;
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6294 PyObject *resultobj;
6295 wxRect *arg1 = (wxRect *) 0 ;
6296 int result;
6297 PyObject * obj0 = 0 ;
6298 char *kwnames[] = {
6299 (char *) "self", NULL
6300 };
6301
6302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6304 if (SWIG_arg_fail(1)) SWIG_fail;
6305 result = (int) ((arg1)->y);
6306
6307 {
6308 resultobj = SWIG_From_int((int)(result));
6309 }
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj;
6318 wxRect *arg1 = (wxRect *) 0 ;
6319 int arg2 ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 char *kwnames[] = {
6323 (char *) "self",(char *) "width", NULL
6324 };
6325
6326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 {
6330 arg2 = (int)(SWIG_As_int(obj1));
6331 if (SWIG_arg_fail(2)) SWIG_fail;
6332 }
6333 if (arg1) (arg1)->width = arg2;
6334
6335 Py_INCREF(Py_None); resultobj = Py_None;
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int result;
6346 PyObject * obj0 = 0 ;
6347 char *kwnames[] = {
6348 (char *) "self", NULL
6349 };
6350
6351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6353 if (SWIG_arg_fail(1)) SWIG_fail;
6354 result = (int) ((arg1)->width);
6355
6356 {
6357 resultobj = SWIG_From_int((int)(result));
6358 }
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxRect *arg1 = (wxRect *) 0 ;
6368 int arg2 ;
6369 PyObject * obj0 = 0 ;
6370 PyObject * obj1 = 0 ;
6371 char *kwnames[] = {
6372 (char *) "self",(char *) "height", NULL
6373 };
6374
6375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6377 if (SWIG_arg_fail(1)) SWIG_fail;
6378 {
6379 arg2 = (int)(SWIG_As_int(obj1));
6380 if (SWIG_arg_fail(2)) SWIG_fail;
6381 }
6382 if (arg1) (arg1)->height = arg2;
6383
6384 Py_INCREF(Py_None); resultobj = Py_None;
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxRect *arg1 = (wxRect *) 0 ;
6394 int result;
6395 PyObject * obj0 = 0 ;
6396 char *kwnames[] = {
6397 (char *) "self", NULL
6398 };
6399
6400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6402 if (SWIG_arg_fail(1)) SWIG_fail;
6403 result = (int) ((arg1)->height);
6404
6405 {
6406 resultobj = SWIG_From_int((int)(result));
6407 }
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj;
6416 wxRect *arg1 = (wxRect *) 0 ;
6417 int arg2 = (int) 0 ;
6418 int arg3 = (int) 0 ;
6419 int arg4 = (int) 0 ;
6420 int arg5 = (int) 0 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 PyObject * obj2 = 0 ;
6424 PyObject * obj3 = 0 ;
6425 PyObject * obj4 = 0 ;
6426 char *kwnames[] = {
6427 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6428 };
6429
6430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6432 if (SWIG_arg_fail(1)) SWIG_fail;
6433 if (obj1) {
6434 {
6435 arg2 = (int)(SWIG_As_int(obj1));
6436 if (SWIG_arg_fail(2)) SWIG_fail;
6437 }
6438 }
6439 if (obj2) {
6440 {
6441 arg3 = (int)(SWIG_As_int(obj2));
6442 if (SWIG_arg_fail(3)) SWIG_fail;
6443 }
6444 }
6445 if (obj3) {
6446 {
6447 arg4 = (int)(SWIG_As_int(obj3));
6448 if (SWIG_arg_fail(4)) SWIG_fail;
6449 }
6450 }
6451 if (obj4) {
6452 {
6453 arg5 = (int)(SWIG_As_int(obj4));
6454 if (SWIG_arg_fail(5)) SWIG_fail;
6455 }
6456 }
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6460
6461 wxPyEndAllowThreads(__tstate);
6462 if (PyErr_Occurred()) SWIG_fail;
6463 }
6464 Py_INCREF(Py_None); resultobj = Py_None;
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 PyObject *result;
6475 PyObject * obj0 = 0 ;
6476 char *kwnames[] = {
6477 (char *) "self", NULL
6478 };
6479
6480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6482 if (SWIG_arg_fail(1)) SWIG_fail;
6483 {
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (PyObject *)wxRect_Get(arg1);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = result;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6498 PyObject *obj;
6499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6500 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6501 Py_INCREF(obj);
6502 return Py_BuildValue((char *)"");
6503 }
6504 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 wxRect *arg2 = (wxRect *) 0 ;
6508 PyObject *result;
6509 PyObject * obj0 = 0 ;
6510 PyObject * obj1 = 0 ;
6511 char *kwnames[] = {
6512 (char *) "r1",(char *) "r2", NULL
6513 };
6514
6515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6517 if (SWIG_arg_fail(1)) SWIG_fail;
6518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(2)) SWIG_fail;
6520 {
6521 if (!wxPyCheckForApp()) SWIG_fail;
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (PyObject *)wxIntersectRect(arg1,arg2);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = result;
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 double arg1 = (double) 0.0 ;
6538 double arg2 = (double) 0.0 ;
6539 wxPoint2D *result;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "x",(char *) "y", NULL
6544 };
6545
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6547 if (obj0) {
6548 {
6549 arg1 = (double)(SWIG_As_double(obj0));
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 }
6552 }
6553 if (obj1) {
6554 {
6555 arg2 = (double)(SWIG_As_double(obj1));
6556 if (SWIG_arg_fail(2)) SWIG_fail;
6557 }
6558 }
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6562
6563 wxPyEndAllowThreads(__tstate);
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6574 PyObject *resultobj;
6575 wxPoint2D *arg1 = 0 ;
6576 wxPoint2D *result;
6577 wxPoint2D temp1 ;
6578 PyObject * obj0 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "pt", NULL
6581 };
6582
6583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6584 {
6585 arg1 = &temp1;
6586 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6587 }
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6603 PyObject *resultobj;
6604 wxPoint *arg1 = 0 ;
6605 wxPoint2D *result;
6606 wxPoint temp1 ;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "pt", NULL
6610 };
6611
6612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6613 {
6614 arg1 = &temp1;
6615 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6616 }
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6625 return resultobj;
6626 fail:
6627 return NULL;
6628 }
6629
6630
6631 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6632 PyObject *resultobj;
6633 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6634 int *arg2 = (int *) 0 ;
6635 int *arg3 = (int *) 0 ;
6636 int temp2 ;
6637 int res2 = 0 ;
6638 int temp3 ;
6639 int res3 = 0 ;
6640 PyObject * obj0 = 0 ;
6641 char *kwnames[] = {
6642 (char *) "self", NULL
6643 };
6644
6645 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6646 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6649 if (SWIG_arg_fail(1)) SWIG_fail;
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6653
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 Py_INCREF(Py_None); resultobj = Py_None;
6658 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6659 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6660 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6661 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6669 PyObject *resultobj;
6670 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6671 int *arg2 = (int *) 0 ;
6672 int *arg3 = (int *) 0 ;
6673 int temp2 ;
6674 int res2 = 0 ;
6675 int temp3 ;
6676 int res3 = 0 ;
6677 PyObject * obj0 = 0 ;
6678 char *kwnames[] = {
6679 (char *) "self", NULL
6680 };
6681
6682 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6683 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6686 if (SWIG_arg_fail(1)) SWIG_fail;
6687 {
6688 PyThreadState* __tstate = wxPyBeginAllowThreads();
6689 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6690
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 Py_INCREF(Py_None); resultobj = Py_None;
6695 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6696 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6697 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6698 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6708 double result;
6709 PyObject * obj0 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6720
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 {
6725 resultobj = SWIG_From_double((double)(result));
6726 }
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6734 PyObject *resultobj;
6735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6736 double result;
6737 PyObject * obj0 = 0 ;
6738 char *kwnames[] = {
6739 (char *) "self", NULL
6740 };
6741
6742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6744 if (SWIG_arg_fail(1)) SWIG_fail;
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6748
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 {
6753 resultobj = SWIG_From_double((double)(result));
6754 }
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6762 PyObject *resultobj;
6763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6764 double arg2 ;
6765 PyObject * obj0 = 0 ;
6766 PyObject * obj1 = 0 ;
6767 char *kwnames[] = {
6768 (char *) "self",(char *) "length", NULL
6769 };
6770
6771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6773 if (SWIG_arg_fail(1)) SWIG_fail;
6774 {
6775 arg2 = (double)(SWIG_As_double(obj1));
6776 if (SWIG_arg_fail(2)) SWIG_fail;
6777 }
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 (arg1)->SetVectorLength(arg2);
6781
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 Py_INCREF(Py_None); resultobj = Py_None;
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj;
6794 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6795 double arg2 ;
6796 PyObject * obj0 = 0 ;
6797 PyObject * obj1 = 0 ;
6798 char *kwnames[] = {
6799 (char *) "self",(char *) "degrees", NULL
6800 };
6801
6802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(1)) SWIG_fail;
6805 {
6806 arg2 = (double)(SWIG_As_double(obj1));
6807 if (SWIG_arg_fail(2)) SWIG_fail;
6808 }
6809 {
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 (arg1)->SetVectorAngle(arg2);
6812
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 Py_INCREF(Py_None); resultobj = Py_None;
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 wxPoint2D *arg2 = 0 ;
6827 double result;
6828 wxPoint2D temp2 ;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char *kwnames[] = {
6832 (char *) "self",(char *) "pt", NULL
6833 };
6834
6835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 {
6839 arg2 = &temp2;
6840 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = SWIG_From_double((double)(result));
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6859 PyObject *resultobj;
6860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6861 wxPoint2D *arg2 = 0 ;
6862 double result;
6863 wxPoint2D temp2 ;
6864 PyObject * obj0 = 0 ;
6865 PyObject * obj1 = 0 ;
6866 char *kwnames[] = {
6867 (char *) "self",(char *) "pt", NULL
6868 };
6869
6870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6872 if (SWIG_arg_fail(1)) SWIG_fail;
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6880
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 {
6885 resultobj = SWIG_From_double((double)(result));
6886 }
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 wxPoint2D *arg2 = 0 ;
6897 double result;
6898 wxPoint2D temp2 ;
6899 PyObject * obj0 = 0 ;
6900 PyObject * obj1 = 0 ;
6901 char *kwnames[] = {
6902 (char *) "self",(char *) "vec", NULL
6903 };
6904
6905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6907 if (SWIG_arg_fail(1)) SWIG_fail;
6908 {
6909 arg2 = &temp2;
6910 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6911 }
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6915
6916 wxPyEndAllowThreads(__tstate);
6917 if (PyErr_Occurred()) SWIG_fail;
6918 }
6919 {
6920 resultobj = SWIG_From_double((double)(result));
6921 }
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj;
6930 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6931 wxPoint2D *arg2 = 0 ;
6932 double result;
6933 wxPoint2D temp2 ;
6934 PyObject * obj0 = 0 ;
6935 PyObject * obj1 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self",(char *) "vec", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6942 if (SWIG_arg_fail(1)) SWIG_fail;
6943 {
6944 arg2 = &temp2;
6945 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6946 }
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 resultobj = SWIG_From_double((double)(result));
6956 }
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6966 wxPoint2D result;
6967 PyObject * obj0 = 0 ;
6968 char *kwnames[] = {
6969 (char *) "self", NULL
6970 };
6971
6972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 result = (arg1)->operator -();
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 {
6983 wxPoint2D * resultptr;
6984 resultptr = new wxPoint2D((wxPoint2D &)(result));
6985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6996 wxPoint2D *arg2 = 0 ;
6997 wxPoint2D *result;
6998 wxPoint2D temp2 ;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "self",(char *) "pt", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 {
7015 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7016 result = (wxPoint2D *) &_result_ref;
7017 }
7018
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7032 wxPoint2D *arg2 = 0 ;
7033 wxPoint2D *result;
7034 wxPoint2D temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "pt", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 {
7051 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7052 result = (wxPoint2D *) &_result_ref;
7053 }
7054
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7068 wxPoint2D *arg2 = 0 ;
7069 wxPoint2D *result;
7070 wxPoint2D temp2 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 char *kwnames[] = {
7074 (char *) "self",(char *) "pt", NULL
7075 };
7076
7077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7079 if (SWIG_arg_fail(1)) SWIG_fail;
7080 {
7081 arg2 = &temp2;
7082 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7083 }
7084 {
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 {
7087 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7088 result = (wxPoint2D *) &_result_ref;
7089 }
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7102 PyObject *resultobj;
7103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7104 wxPoint2D *arg2 = 0 ;
7105 wxPoint2D *result;
7106 wxPoint2D temp2 ;
7107 PyObject * obj0 = 0 ;
7108 PyObject * obj1 = 0 ;
7109 char *kwnames[] = {
7110 (char *) "self",(char *) "pt", NULL
7111 };
7112
7113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7115 if (SWIG_arg_fail(1)) SWIG_fail;
7116 {
7117 arg2 = &temp2;
7118 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7119 }
7120 {
7121 PyThreadState* __tstate = wxPyBeginAllowThreads();
7122 {
7123 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7124 result = (wxPoint2D *) &_result_ref;
7125 }
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7138 PyObject *resultobj;
7139 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7140 wxPoint2D *arg2 = 0 ;
7141 bool result;
7142 wxPoint2D temp2 ;
7143 PyObject * obj0 = 0 ;
7144 PyObject * obj1 = 0 ;
7145 char *kwnames[] = {
7146 (char *) "self",(char *) "pt", NULL
7147 };
7148
7149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7151 if (SWIG_arg_fail(1)) SWIG_fail;
7152 {
7153 arg2 = &temp2;
7154 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7155 }
7156 {
7157 PyThreadState* __tstate = wxPyBeginAllowThreads();
7158 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7159
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 {
7164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7165 }
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj;
7174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7175 wxPoint2D *arg2 = 0 ;
7176 bool result;
7177 wxPoint2D temp2 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "pt", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = &temp2;
7189 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7190 }
7191 {
7192 PyThreadState* __tstate = wxPyBeginAllowThreads();
7193 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7194
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 {
7199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7200 }
7201 return resultobj;
7202 fail:
7203 return NULL;
7204 }
7205
7206
7207 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7210 double arg2 ;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self",(char *) "m_x", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 {
7221 arg2 = (double)(SWIG_As_double(obj1));
7222 if (SWIG_arg_fail(2)) SWIG_fail;
7223 }
7224 if (arg1) (arg1)->m_x = arg2;
7225
7226 Py_INCREF(Py_None); resultobj = Py_None;
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj;
7235 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7236 double result;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 result = (double) ((arg1)->m_x);
7246
7247 {
7248 resultobj = SWIG_From_double((double)(result));
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj;
7258 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7259 double arg2 ;
7260 PyObject * obj0 = 0 ;
7261 PyObject * obj1 = 0 ;
7262 char *kwnames[] = {
7263 (char *) "self",(char *) "m_y", NULL
7264 };
7265
7266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7268 if (SWIG_arg_fail(1)) SWIG_fail;
7269 {
7270 arg2 = (double)(SWIG_As_double(obj1));
7271 if (SWIG_arg_fail(2)) SWIG_fail;
7272 }
7273 if (arg1) (arg1)->m_y = arg2;
7274
7275 Py_INCREF(Py_None); resultobj = Py_None;
7276 return resultobj;
7277 fail:
7278 return NULL;
7279 }
7280
7281
7282 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7283 PyObject *resultobj;
7284 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7285 double result;
7286 PyObject * obj0 = 0 ;
7287 char *kwnames[] = {
7288 (char *) "self", NULL
7289 };
7290
7291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7293 if (SWIG_arg_fail(1)) SWIG_fail;
7294 result = (double) ((arg1)->m_y);
7295
7296 {
7297 resultobj = SWIG_From_double((double)(result));
7298 }
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj;
7307 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7308 double arg2 = (double) 0 ;
7309 double arg3 = (double) 0 ;
7310 PyObject * obj0 = 0 ;
7311 PyObject * obj1 = 0 ;
7312 PyObject * obj2 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self",(char *) "x",(char *) "y", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 if (obj1) {
7321 {
7322 arg2 = (double)(SWIG_As_double(obj1));
7323 if (SWIG_arg_fail(2)) SWIG_fail;
7324 }
7325 }
7326 if (obj2) {
7327 {
7328 arg3 = (double)(SWIG_As_double(obj2));
7329 if (SWIG_arg_fail(3)) SWIG_fail;
7330 }
7331 }
7332 {
7333 PyThreadState* __tstate = wxPyBeginAllowThreads();
7334 wxPoint2D_Set(arg1,arg2,arg3);
7335
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 Py_INCREF(Py_None); resultobj = Py_None;
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj;
7348 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7349 PyObject *result;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (PyObject *)wxPoint2D_Get(arg1);
7361
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 resultobj = result;
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7373 PyObject *obj;
7374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7375 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7376 Py_INCREF(obj);
7377 return Py_BuildValue((char *)"");
7378 }
7379 static int _wrap_DefaultPosition_set(PyObject *) {
7380 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7381 return 1;
7382 }
7383
7384
7385 static PyObject *_wrap_DefaultPosition_get(void) {
7386 PyObject *pyobj;
7387
7388 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7389 return pyobj;
7390 }
7391
7392
7393 static int _wrap_DefaultSize_set(PyObject *) {
7394 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7395 return 1;
7396 }
7397
7398
7399 static PyObject *_wrap_DefaultSize_get(void) {
7400 PyObject *pyobj;
7401
7402 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7403 return pyobj;
7404 }
7405
7406
7407 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 PyObject *arg1 = (PyObject *) 0 ;
7410 wxPyInputStream *result;
7411 PyObject * obj0 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "p", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7417 arg1 = obj0;
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7421
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7426 return resultobj;
7427 fail:
7428 return NULL;
7429 }
7430
7431
7432 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7433 PyObject *resultobj;
7434 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7435 PyObject * obj0 = 0 ;
7436 char *kwnames[] = {
7437 (char *) "self", NULL
7438 };
7439
7440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7442 if (SWIG_arg_fail(1)) SWIG_fail;
7443 {
7444 PyThreadState* __tstate = wxPyBeginAllowThreads();
7445 delete arg1;
7446
7447 wxPyEndAllowThreads(__tstate);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 Py_INCREF(Py_None); resultobj = Py_None;
7451 return resultobj;
7452 fail:
7453 return NULL;
7454 }
7455
7456
7457 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7458 PyObject *resultobj;
7459 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7460 PyObject * obj0 = 0 ;
7461 char *kwnames[] = {
7462 (char *) "self", NULL
7463 };
7464
7465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(1)) SWIG_fail;
7468 {
7469 PyThreadState* __tstate = wxPyBeginAllowThreads();
7470 (arg1)->close();
7471
7472 wxPyEndAllowThreads(__tstate);
7473 if (PyErr_Occurred()) SWIG_fail;
7474 }
7475 Py_INCREF(Py_None); resultobj = Py_None;
7476 return resultobj;
7477 fail:
7478 return NULL;
7479 }
7480
7481
7482 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7483 PyObject *resultobj;
7484 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7485 PyObject * obj0 = 0 ;
7486 char *kwnames[] = {
7487 (char *) "self", NULL
7488 };
7489
7490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7492 if (SWIG_arg_fail(1)) SWIG_fail;
7493 {
7494 PyThreadState* __tstate = wxPyBeginAllowThreads();
7495 (arg1)->flush();
7496
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 Py_INCREF(Py_None); resultobj = Py_None;
7501 return resultobj;
7502 fail:
7503 return NULL;
7504 }
7505
7506
7507 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7508 PyObject *resultobj;
7509 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7510 bool result;
7511 PyObject * obj0 = 0 ;
7512 char *kwnames[] = {
7513 (char *) "self", NULL
7514 };
7515
7516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7518 if (SWIG_arg_fail(1)) SWIG_fail;
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (bool)(arg1)->eof();
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 {
7527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7528 }
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj;
7537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7538 int arg2 = (int) -1 ;
7539 PyObject *result;
7540 PyObject * obj0 = 0 ;
7541 PyObject * obj1 = 0 ;
7542 char *kwnames[] = {
7543 (char *) "self",(char *) "size", NULL
7544 };
7545
7546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7548 if (SWIG_arg_fail(1)) SWIG_fail;
7549 if (obj1) {
7550 {
7551 arg2 = (int)(SWIG_As_int(obj1));
7552 if (SWIG_arg_fail(2)) SWIG_fail;
7553 }
7554 }
7555 {
7556 PyThreadState* __tstate = wxPyBeginAllowThreads();
7557 result = (PyObject *)(arg1)->read(arg2);
7558
7559 wxPyEndAllowThreads(__tstate);
7560 if (PyErr_Occurred()) SWIG_fail;
7561 }
7562 resultobj = result;
7563 return resultobj;
7564 fail:
7565 return NULL;
7566 }
7567
7568
7569 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7570 PyObject *resultobj;
7571 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7572 int arg2 = (int) -1 ;
7573 PyObject *result;
7574 PyObject * obj0 = 0 ;
7575 PyObject * obj1 = 0 ;
7576 char *kwnames[] = {
7577 (char *) "self",(char *) "size", NULL
7578 };
7579
7580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7582 if (SWIG_arg_fail(1)) SWIG_fail;
7583 if (obj1) {
7584 {
7585 arg2 = (int)(SWIG_As_int(obj1));
7586 if (SWIG_arg_fail(2)) SWIG_fail;
7587 }
7588 }
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (PyObject *)(arg1)->readline(arg2);
7592
7593 wxPyEndAllowThreads(__tstate);
7594 if (PyErr_Occurred()) SWIG_fail;
7595 }
7596 resultobj = result;
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7604 PyObject *resultobj;
7605 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7606 int arg2 = (int) -1 ;
7607 PyObject *result;
7608 PyObject * obj0 = 0 ;
7609 PyObject * obj1 = 0 ;
7610 char *kwnames[] = {
7611 (char *) "self",(char *) "sizehint", NULL
7612 };
7613
7614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7616 if (SWIG_arg_fail(1)) SWIG_fail;
7617 if (obj1) {
7618 {
7619 arg2 = (int)(SWIG_As_int(obj1));
7620 if (SWIG_arg_fail(2)) SWIG_fail;
7621 }
7622 }
7623 {
7624 PyThreadState* __tstate = wxPyBeginAllowThreads();
7625 result = (PyObject *)(arg1)->readlines(arg2);
7626
7627 wxPyEndAllowThreads(__tstate);
7628 if (PyErr_Occurred()) SWIG_fail;
7629 }
7630 resultobj = result;
7631 return resultobj;
7632 fail:
7633 return NULL;
7634 }
7635
7636
7637 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj;
7639 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7640 int arg2 ;
7641 int arg3 = (int) 0 ;
7642 PyObject * obj0 = 0 ;
7643 PyObject * obj1 = 0 ;
7644 PyObject * obj2 = 0 ;
7645 char *kwnames[] = {
7646 (char *) "self",(char *) "offset",(char *) "whence", NULL
7647 };
7648
7649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7651 if (SWIG_arg_fail(1)) SWIG_fail;
7652 {
7653 arg2 = (int)(SWIG_As_int(obj1));
7654 if (SWIG_arg_fail(2)) SWIG_fail;
7655 }
7656 if (obj2) {
7657 {
7658 arg3 = (int)(SWIG_As_int(obj2));
7659 if (SWIG_arg_fail(3)) SWIG_fail;
7660 }
7661 }
7662 {
7663 PyThreadState* __tstate = wxPyBeginAllowThreads();
7664 (arg1)->seek(arg2,arg3);
7665
7666 wxPyEndAllowThreads(__tstate);
7667 if (PyErr_Occurred()) SWIG_fail;
7668 }
7669 Py_INCREF(Py_None); resultobj = Py_None;
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 int result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (int)(arg1)->tell();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = SWIG_From_int((int)(result));
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 char result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (char)(arg1)->Peek();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = SWIG_From_char((char)(result));
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 char result;
7736 PyObject * obj0 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (char)(arg1)->GetC();
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = SWIG_From_char((char)(result));
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7763 size_t result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (size_t)(arg1)->LastRead();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7791 bool result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = (bool)(arg1)->CanRead();
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7819 bool result;
7820 PyObject * obj0 = 0 ;
7821 char *kwnames[] = {
7822 (char *) "self", NULL
7823 };
7824
7825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7827 if (SWIG_arg_fail(1)) SWIG_fail;
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 result = (bool)(arg1)->Eof();
7831
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 {
7836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7837 }
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7845 PyObject *resultobj;
7846 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7847 char arg2 ;
7848 bool result;
7849 PyObject * obj0 = 0 ;
7850 PyObject * obj1 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self",(char *) "c", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 {
7859 arg2 = (char)(SWIG_As_char(obj1));
7860 if (SWIG_arg_fail(2)) SWIG_fail;
7861 }
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (bool)(arg1)->Ungetch(arg2);
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 {
7870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7871 }
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7881 long arg2 ;
7882 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7883 long result;
7884 PyObject * obj0 = 0 ;
7885 PyObject * obj1 = 0 ;
7886 PyObject * obj2 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self",(char *) "pos",(char *) "mode", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 arg2 = (long)(SWIG_As_long(obj1));
7896 if (SWIG_arg_fail(2)) SWIG_fail;
7897 }
7898 if (obj2) {
7899 {
7900 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7901 if (SWIG_arg_fail(3)) SWIG_fail;
7902 }
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = SWIG_From_long((long)(result));
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7923 long result;
7924 PyObject * obj0 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "self", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(1)) SWIG_fail;
7932 {
7933 PyThreadState* __tstate = wxPyBeginAllowThreads();
7934 result = (long)(arg1)->TellI();
7935
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 {
7940 resultobj = SWIG_From_long((long)(result));
7941 }
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7949 PyObject *obj;
7950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7951 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7952 Py_INCREF(obj);
7953 return Py_BuildValue((char *)"");
7954 }
7955 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj;
7957 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7958 PyObject *arg2 = (PyObject *) 0 ;
7959 PyObject * obj0 = 0 ;
7960 PyObject * obj1 = 0 ;
7961 char *kwnames[] = {
7962 (char *) "self",(char *) "obj", NULL
7963 };
7964
7965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7967 if (SWIG_arg_fail(1)) SWIG_fail;
7968 arg2 = obj1;
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 wxOutputStream_write(arg1,arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 Py_INCREF(Py_None); resultobj = Py_None;
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7984 PyObject *obj;
7985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7986 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7987 Py_INCREF(obj);
7988 return Py_BuildValue((char *)"");
7989 }
7990 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7991 PyObject *resultobj;
7992 wxInputStream *arg1 = (wxInputStream *) 0 ;
7993 wxString *arg2 = 0 ;
7994 wxString *arg3 = 0 ;
7995 wxString *arg4 = 0 ;
7996 wxDateTime arg5 ;
7997 wxFSFile *result;
7998 wxPyInputStream *temp1 ;
7999 bool temp2 = false ;
8000 bool temp3 = false ;
8001 bool temp4 = false ;
8002 PyObject * obj0 = 0 ;
8003 PyObject * obj1 = 0 ;
8004 PyObject * obj2 = 0 ;
8005 PyObject * obj3 = 0 ;
8006 PyObject * obj4 = 0 ;
8007 char *kwnames[] = {
8008 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8009 };
8010
8011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8012 {
8013 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8014 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8015 } else {
8016 PyErr_Clear(); // clear the failure of the wxPyConvert above
8017 arg1 = wxPyCBInputStream_create(obj0, true);
8018 if (arg1 == NULL) {
8019 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8020 SWIG_fail;
8021 }
8022 }
8023 }
8024 {
8025 arg2 = wxString_in_helper(obj1);
8026 if (arg2 == NULL) SWIG_fail;
8027 temp2 = true;
8028 }
8029 {
8030 arg3 = wxString_in_helper(obj2);
8031 if (arg3 == NULL) SWIG_fail;
8032 temp3 = true;
8033 }
8034 {
8035 arg4 = wxString_in_helper(obj3);
8036 if (arg4 == NULL) SWIG_fail;
8037 temp4 = true;
8038 }
8039 {
8040 wxDateTime * argp;
8041 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8042 if (SWIG_arg_fail(5)) SWIG_fail;
8043 if (argp == NULL) {
8044 SWIG_null_ref("wxDateTime");
8045 }
8046 if (SWIG_arg_fail(5)) SWIG_fail;
8047 arg5 = *argp;
8048 }
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 {
8057 resultobj = wxPyMake_wxObject(result, 1);
8058 }
8059 {
8060 if (temp2)
8061 delete arg2;
8062 }
8063 {
8064 if (temp3)
8065 delete arg3;
8066 }
8067 {
8068 if (temp4)
8069 delete arg4;
8070 }
8071 return resultobj;
8072 fail:
8073 {
8074 if (temp2)
8075 delete arg2;
8076 }
8077 {
8078 if (temp3)
8079 delete arg3;
8080 }
8081 {
8082 if (temp4)
8083 delete arg4;
8084 }
8085 return NULL;
8086 }
8087
8088
8089 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8090 PyObject *resultobj;
8091 wxFSFile *arg1 = (wxFSFile *) 0 ;
8092 PyObject * obj0 = 0 ;
8093 char *kwnames[] = {
8094 (char *) "self", NULL
8095 };
8096
8097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8099 if (SWIG_arg_fail(1)) SWIG_fail;
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 delete arg1;
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 Py_INCREF(Py_None); resultobj = Py_None;
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8115 PyObject *resultobj;
8116 wxFSFile *arg1 = (wxFSFile *) 0 ;
8117 wxInputStream *result;
8118 PyObject * obj0 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "self", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8125 if (SWIG_arg_fail(1)) SWIG_fail;
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 result = (wxInputStream *)(arg1)->GetStream();
8129
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 {
8134 wxPyInputStream * _ptr = NULL;
8135
8136 if (result) {
8137 _ptr = new wxPyInputStream(result);
8138 }
8139 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8140 }
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxFSFile *arg1 = (wxFSFile *) 0 ;
8150 wxString *result;
8151 PyObject * obj0 = 0 ;
8152 char *kwnames[] = {
8153 (char *) "self", NULL
8154 };
8155
8156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8158 if (SWIG_arg_fail(1)) SWIG_fail;
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 {
8162 wxString const &_result_ref = (arg1)->GetMimeType();
8163 result = (wxString *) &_result_ref;
8164 }
8165
8166 wxPyEndAllowThreads(__tstate);
8167 if (PyErr_Occurred()) SWIG_fail;
8168 }
8169 {
8170 #if wxUSE_UNICODE
8171 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8172 #else
8173 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8174 #endif
8175 }
8176 return resultobj;
8177 fail:
8178 return NULL;
8179 }
8180
8181
8182 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj;
8184 wxFSFile *arg1 = (wxFSFile *) 0 ;
8185 wxString *result;
8186 PyObject * obj0 = 0 ;
8187 char *kwnames[] = {
8188 (char *) "self", NULL
8189 };
8190
8191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8193 if (SWIG_arg_fail(1)) SWIG_fail;
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 {
8197 wxString const &_result_ref = (arg1)->GetLocation();
8198 result = (wxString *) &_result_ref;
8199 }
8200
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 {
8205 #if wxUSE_UNICODE
8206 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8207 #else
8208 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8209 #endif
8210 }
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8218 PyObject *resultobj;
8219 wxFSFile *arg1 = (wxFSFile *) 0 ;
8220 wxString *result;
8221 PyObject * obj0 = 0 ;
8222 char *kwnames[] = {
8223 (char *) "self", NULL
8224 };
8225
8226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8228 if (SWIG_arg_fail(1)) SWIG_fail;
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 {
8232 wxString const &_result_ref = (arg1)->GetAnchor();
8233 result = (wxString *) &_result_ref;
8234 }
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 {
8240 #if wxUSE_UNICODE
8241 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8242 #else
8243 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8244 #endif
8245 }
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj;
8254 wxFSFile *arg1 = (wxFSFile *) 0 ;
8255 wxDateTime result;
8256 PyObject * obj0 = 0 ;
8257 char *kwnames[] = {
8258 (char *) "self", NULL
8259 };
8260
8261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8263 if (SWIG_arg_fail(1)) SWIG_fail;
8264 {
8265 PyThreadState* __tstate = wxPyBeginAllowThreads();
8266 result = (arg1)->GetModificationTime();
8267
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 {
8272 wxDateTime * resultptr;
8273 resultptr = new wxDateTime((wxDateTime &)(result));
8274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8275 }
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8283 PyObject *obj;
8284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8285 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8286 Py_INCREF(obj);
8287 return Py_BuildValue((char *)"");
8288 }
8289 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8290 PyObject *obj;
8291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8292 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8293 Py_INCREF(obj);
8294 return Py_BuildValue((char *)"");
8295 }
8296 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj;
8298 wxPyFileSystemHandler *result;
8299 char *kwnames[] = {
8300 NULL
8301 };
8302
8303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8307
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj;
8320 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8321 PyObject *arg2 = (PyObject *) 0 ;
8322 PyObject *arg3 = (PyObject *) 0 ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 PyObject * obj2 = 0 ;
8326 char *kwnames[] = {
8327 (char *) "self",(char *) "self",(char *) "_class", NULL
8328 };
8329
8330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8332 if (SWIG_arg_fail(1)) SWIG_fail;
8333 arg2 = obj1;
8334 arg3 = obj2;
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 (arg1)->_setCallbackInfo(arg2,arg3);
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 Py_INCREF(Py_None); resultobj = Py_None;
8343 return resultobj;
8344 fail:
8345 return NULL;
8346 }
8347
8348
8349 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj;
8351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8352 wxString *arg2 = 0 ;
8353 bool result;
8354 bool temp2 = false ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 char *kwnames[] = {
8358 (char *) "self",(char *) "location", NULL
8359 };
8360
8361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8363 if (SWIG_arg_fail(1)) SWIG_fail;
8364 {
8365 arg2 = wxString_in_helper(obj1);
8366 if (arg2 == NULL) SWIG_fail;
8367 temp2 = true;
8368 }
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 {
8377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8378 }
8379 {
8380 if (temp2)
8381 delete arg2;
8382 }
8383 return resultobj;
8384 fail:
8385 {
8386 if (temp2)
8387 delete arg2;
8388 }
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8396 wxFileSystem *arg2 = 0 ;
8397 wxString *arg3 = 0 ;
8398 wxFSFile *result;
8399 bool temp3 = false ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 PyObject * obj2 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self",(char *) "fs",(char *) "location", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8412 if (SWIG_arg_fail(2)) SWIG_fail;
8413 if (arg2 == NULL) {
8414 SWIG_null_ref("wxFileSystem");
8415 }
8416 if (SWIG_arg_fail(2)) SWIG_fail;
8417 }
8418 {
8419 arg3 = wxString_in_helper(obj2);
8420 if (arg3 == NULL) SWIG_fail;
8421 temp3 = true;
8422 }
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8426
8427 wxPyEndAllowThreads(__tstate);
8428 if (PyErr_Occurred()) SWIG_fail;
8429 }
8430 {
8431 resultobj = wxPyMake_wxObject(result, 1);
8432 }
8433 {
8434 if (temp3)
8435 delete arg3;
8436 }
8437 return resultobj;
8438 fail:
8439 {
8440 if (temp3)
8441 delete arg3;
8442 }
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8450 wxString *arg2 = 0 ;
8451 int arg3 = (int) 0 ;
8452 wxString result;
8453 bool temp2 = false ;
8454 PyObject * obj0 = 0 ;
8455 PyObject * obj1 = 0 ;
8456 PyObject * obj2 = 0 ;
8457 char *kwnames[] = {
8458 (char *) "self",(char *) "spec",(char *) "flags", NULL
8459 };
8460
8461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8463 if (SWIG_arg_fail(1)) SWIG_fail;
8464 {
8465 arg2 = wxString_in_helper(obj1);
8466 if (arg2 == NULL) SWIG_fail;
8467 temp2 = true;
8468 }
8469 if (obj2) {
8470 {
8471 arg3 = (int)(SWIG_As_int(obj2));
8472 if (SWIG_arg_fail(3)) SWIG_fail;
8473 }
8474 }
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8478
8479 wxPyEndAllowThreads(__tstate);
8480 if (PyErr_Occurred()) SWIG_fail;
8481 }
8482 {
8483 #if wxUSE_UNICODE
8484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8485 #else
8486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8487 #endif
8488 }
8489 {
8490 if (temp2)
8491 delete arg2;
8492 }
8493 return resultobj;
8494 fail:
8495 {
8496 if (temp2)
8497 delete arg2;
8498 }
8499 return NULL;
8500 }
8501
8502
8503 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj;
8505 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8506 wxString result;
8507 PyObject * obj0 = 0 ;
8508 char *kwnames[] = {
8509 (char *) "self", NULL
8510 };
8511
8512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8514 if (SWIG_arg_fail(1)) SWIG_fail;
8515 {
8516 PyThreadState* __tstate = wxPyBeginAllowThreads();
8517 result = (arg1)->FindNext();
8518
8519 wxPyEndAllowThreads(__tstate);
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 {
8523 #if wxUSE_UNICODE
8524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8525 #else
8526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8527 #endif
8528 }
8529 return resultobj;
8530 fail:
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj;
8537 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8538 wxString *arg2 = 0 ;
8539 wxString result;
8540 bool temp2 = false ;
8541 PyObject * obj0 = 0 ;
8542 PyObject * obj1 = 0 ;
8543 char *kwnames[] = {
8544 (char *) "self",(char *) "location", NULL
8545 };
8546
8547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8549 if (SWIG_arg_fail(1)) SWIG_fail;
8550 {
8551 arg2 = wxString_in_helper(obj1);
8552 if (arg2 == NULL) SWIG_fail;
8553 temp2 = true;
8554 }
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (arg1)->GetProtocol((wxString const &)*arg2);
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 #if wxUSE_UNICODE
8564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8565 #else
8566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8567 #endif
8568 }
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return resultobj;
8574 fail:
8575 {
8576 if (temp2)
8577 delete arg2;
8578 }
8579 return NULL;
8580 }
8581
8582
8583 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj;
8585 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8586 wxString *arg2 = 0 ;
8587 wxString result;
8588 bool temp2 = false ;
8589 PyObject * obj0 = 0 ;
8590 PyObject * obj1 = 0 ;
8591 char *kwnames[] = {
8592 (char *) "self",(char *) "location", NULL
8593 };
8594
8595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8597 if (SWIG_arg_fail(1)) SWIG_fail;
8598 {
8599 arg2 = wxString_in_helper(obj1);
8600 if (arg2 == NULL) SWIG_fail;
8601 temp2 = true;
8602 }
8603 {
8604 PyThreadState* __tstate = wxPyBeginAllowThreads();
8605 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8606
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 {
8611 #if wxUSE_UNICODE
8612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8613 #else
8614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8615 #endif
8616 }
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return resultobj;
8622 fail:
8623 {
8624 if (temp2)
8625 delete arg2;
8626 }
8627 return NULL;
8628 }
8629
8630
8631 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8632 PyObject *resultobj;
8633 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8634 wxString *arg2 = 0 ;
8635 wxString result;
8636 bool temp2 = false ;
8637 PyObject * obj0 = 0 ;
8638 PyObject * obj1 = 0 ;
8639 char *kwnames[] = {
8640 (char *) "self",(char *) "location", NULL
8641 };
8642
8643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8645 if (SWIG_arg_fail(1)) SWIG_fail;
8646 {
8647 arg2 = wxString_in_helper(obj1);
8648 if (arg2 == NULL) SWIG_fail;
8649 temp2 = true;
8650 }
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 result = (arg1)->GetAnchor((wxString const &)*arg2);
8654
8655 wxPyEndAllowThreads(__tstate);
8656 if (PyErr_Occurred()) SWIG_fail;
8657 }
8658 {
8659 #if wxUSE_UNICODE
8660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8661 #else
8662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8663 #endif
8664 }
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return resultobj;
8670 fail:
8671 {
8672 if (temp2)
8673 delete arg2;
8674 }
8675 return NULL;
8676 }
8677
8678
8679 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj;
8681 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8682 wxString *arg2 = 0 ;
8683 wxString result;
8684 bool temp2 = false ;
8685 PyObject * obj0 = 0 ;
8686 PyObject * obj1 = 0 ;
8687 char *kwnames[] = {
8688 (char *) "self",(char *) "location", NULL
8689 };
8690
8691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8693 if (SWIG_arg_fail(1)) SWIG_fail;
8694 {
8695 arg2 = wxString_in_helper(obj1);
8696 if (arg2 == NULL) SWIG_fail;
8697 temp2 = true;
8698 }
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8702
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 {
8707 #if wxUSE_UNICODE
8708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8709 #else
8710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8711 #endif
8712 }
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return resultobj;
8718 fail:
8719 {
8720 if (temp2)
8721 delete arg2;
8722 }
8723 return NULL;
8724 }
8725
8726
8727 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8728 PyObject *resultobj;
8729 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8730 wxString *arg2 = 0 ;
8731 wxString result;
8732 bool temp2 = false ;
8733 PyObject * obj0 = 0 ;
8734 PyObject * obj1 = 0 ;
8735 char *kwnames[] = {
8736 (char *) "self",(char *) "location", NULL
8737 };
8738
8739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8741 if (SWIG_arg_fail(1)) SWIG_fail;
8742 {
8743 arg2 = wxString_in_helper(obj1);
8744 if (arg2 == NULL) SWIG_fail;
8745 temp2 = true;
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8750
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 {
8755 #if wxUSE_UNICODE
8756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8757 #else
8758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8759 #endif
8760 }
8761 {
8762 if (temp2)
8763 delete arg2;
8764 }
8765 return resultobj;
8766 fail:
8767 {
8768 if (temp2)
8769 delete arg2;
8770 }
8771 return NULL;
8772 }
8773
8774
8775 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8776 PyObject *obj;
8777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8778 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8779 Py_INCREF(obj);
8780 return Py_BuildValue((char *)"");
8781 }
8782 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxFileSystem *result;
8785 char *kwnames[] = {
8786 NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (wxFileSystem *)new wxFileSystem();
8793
8794 wxPyEndAllowThreads(__tstate);
8795 if (PyErr_Occurred()) SWIG_fail;
8796 }
8797 {
8798 resultobj = wxPyMake_wxObject(result, 1);
8799 }
8800 return resultobj;
8801 fail:
8802 return NULL;
8803 }
8804
8805
8806 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8807 PyObject *resultobj;
8808 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8809 PyObject * obj0 = 0 ;
8810 char *kwnames[] = {
8811 (char *) "self", NULL
8812 };
8813
8814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8816 if (SWIG_arg_fail(1)) SWIG_fail;
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 delete arg1;
8820
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 Py_INCREF(Py_None); resultobj = Py_None;
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj;
8833 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8834 wxString *arg2 = 0 ;
8835 bool arg3 = (bool) false ;
8836 bool temp2 = false ;
8837 PyObject * obj0 = 0 ;
8838 PyObject * obj1 = 0 ;
8839 PyObject * obj2 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8846 if (SWIG_arg_fail(1)) SWIG_fail;
8847 {
8848 arg2 = wxString_in_helper(obj1);
8849 if (arg2 == NULL) SWIG_fail;
8850 temp2 = true;
8851 }
8852 if (obj2) {
8853 {
8854 arg3 = (bool)(SWIG_As_bool(obj2));
8855 if (SWIG_arg_fail(3)) SWIG_fail;
8856 }
8857 }
8858 {
8859 PyThreadState* __tstate = wxPyBeginAllowThreads();
8860 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8861
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 Py_INCREF(Py_None); resultobj = Py_None;
8866 {
8867 if (temp2)
8868 delete arg2;
8869 }
8870 return resultobj;
8871 fail:
8872 {
8873 if (temp2)
8874 delete arg2;
8875 }
8876 return NULL;
8877 }
8878
8879
8880 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj;
8882 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8883 wxString result;
8884 PyObject * obj0 = 0 ;
8885 char *kwnames[] = {
8886 (char *) "self", NULL
8887 };
8888
8889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8891 if (SWIG_arg_fail(1)) SWIG_fail;
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 result = (arg1)->GetPath();
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 {
8900 #if wxUSE_UNICODE
8901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8902 #else
8903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8904 #endif
8905 }
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8915 wxString *arg2 = 0 ;
8916 wxFSFile *result;
8917 bool temp2 = false ;
8918 PyObject * obj0 = 0 ;
8919 PyObject * obj1 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "self",(char *) "location", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 arg2 = wxString_in_helper(obj1);
8929 if (arg2 == NULL) SWIG_fail;
8930 temp2 = true;
8931 }
8932 {
8933 PyThreadState* __tstate = wxPyBeginAllowThreads();
8934 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8935
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 {
8940 resultobj = wxPyMake_wxObject(result, 1);
8941 }
8942 {
8943 if (temp2)
8944 delete arg2;
8945 }
8946 return resultobj;
8947 fail:
8948 {
8949 if (temp2)
8950 delete arg2;
8951 }
8952 return NULL;
8953 }
8954
8955
8956 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj;
8958 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8959 wxString *arg2 = 0 ;
8960 int arg3 = (int) 0 ;
8961 wxString result;
8962 bool temp2 = false ;
8963 PyObject * obj0 = 0 ;
8964 PyObject * obj1 = 0 ;
8965 PyObject * obj2 = 0 ;
8966 char *kwnames[] = {
8967 (char *) "self",(char *) "spec",(char *) "flags", NULL
8968 };
8969
8970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8972 if (SWIG_arg_fail(1)) SWIG_fail;
8973 {
8974 arg2 = wxString_in_helper(obj1);
8975 if (arg2 == NULL) SWIG_fail;
8976 temp2 = true;
8977 }
8978 if (obj2) {
8979 {
8980 arg3 = (int)(SWIG_As_int(obj2));
8981 if (SWIG_arg_fail(3)) SWIG_fail;
8982 }
8983 }
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8987
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 {
8992 #if wxUSE_UNICODE
8993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8994 #else
8995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8996 #endif
8997 }
8998 {
8999 if (temp2)
9000 delete arg2;
9001 }
9002 return resultobj;
9003 fail:
9004 {
9005 if (temp2)
9006 delete arg2;
9007 }
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9015 wxString result;
9016 PyObject * obj0 = 0 ;
9017 char *kwnames[] = {
9018 (char *) "self", NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9023 if (SWIG_arg_fail(1)) SWIG_fail;
9024 {
9025 PyThreadState* __tstate = wxPyBeginAllowThreads();
9026 result = (arg1)->FindNext();
9027
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 {
9032 #if wxUSE_UNICODE
9033 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9034 #else
9035 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9036 #endif
9037 }
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj;
9046 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9047 PyObject * obj0 = 0 ;
9048 char *kwnames[] = {
9049 (char *) "handler", NULL
9050 };
9051
9052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9054 if (SWIG_arg_fail(1)) SWIG_fail;
9055 {
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 wxFileSystem::AddHandler(arg1);
9058
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 Py_INCREF(Py_None); resultobj = Py_None;
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj;
9071 char *kwnames[] = {
9072 NULL
9073 };
9074
9075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 wxFileSystem::CleanUpHandlers();
9079
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 Py_INCREF(Py_None); resultobj = Py_None;
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9091 PyObject *resultobj;
9092 wxString *arg1 = 0 ;
9093 wxString result;
9094 bool temp1 = false ;
9095 PyObject * obj0 = 0 ;
9096 char *kwnames[] = {
9097 (char *) "filename", NULL
9098 };
9099
9100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9101 {
9102 arg1 = wxString_in_helper(obj0);
9103 if (arg1 == NULL) SWIG_fail;
9104 temp1 = true;
9105 }
9106 {
9107 PyThreadState* __tstate = wxPyBeginAllowThreads();
9108 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9109
9110 wxPyEndAllowThreads(__tstate);
9111 if (PyErr_Occurred()) SWIG_fail;
9112 }
9113 {
9114 #if wxUSE_UNICODE
9115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9116 #else
9117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9118 #endif
9119 }
9120 {
9121 if (temp1)
9122 delete arg1;
9123 }
9124 return resultobj;
9125 fail:
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return NULL;
9131 }
9132
9133
9134 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9135 PyObject *resultobj;
9136 wxString *arg1 = 0 ;
9137 wxString result;
9138 bool temp1 = false ;
9139 PyObject * obj0 = 0 ;
9140 char *kwnames[] = {
9141 (char *) "url", NULL
9142 };
9143
9144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9145 {
9146 arg1 = wxString_in_helper(obj0);
9147 if (arg1 == NULL) SWIG_fail;
9148 temp1 = true;
9149 }
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 result = FileSystem_URLToFileName((wxString const &)*arg1);
9153
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 {
9158 #if wxUSE_UNICODE
9159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9160 #else
9161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9162 #endif
9163 }
9164 {
9165 if (temp1)
9166 delete arg1;
9167 }
9168 return resultobj;
9169 fail:
9170 {
9171 if (temp1)
9172 delete arg1;
9173 }
9174 return NULL;
9175 }
9176
9177
9178 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9179 PyObject *obj;
9180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9181 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9182 Py_INCREF(obj);
9183 return Py_BuildValue((char *)"");
9184 }
9185 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 wxInternetFSHandler *result;
9188 char *kwnames[] = {
9189 NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9196
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9201 return resultobj;
9202 fail:
9203 return NULL;
9204 }
9205
9206
9207 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9208 PyObject *resultobj;
9209 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9210 wxString *arg2 = 0 ;
9211 bool result;
9212 bool temp2 = false ;
9213 PyObject * obj0 = 0 ;
9214 PyObject * obj1 = 0 ;
9215 char *kwnames[] = {
9216 (char *) "self",(char *) "location", NULL
9217 };
9218
9219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9221 if (SWIG_arg_fail(1)) SWIG_fail;
9222 {
9223 arg2 = wxString_in_helper(obj1);
9224 if (arg2 == NULL) SWIG_fail;
9225 temp2 = true;
9226 }
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 {
9235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9236 }
9237 {
9238 if (temp2)
9239 delete arg2;
9240 }
9241 return resultobj;
9242 fail:
9243 {
9244 if (temp2)
9245 delete arg2;
9246 }
9247 return NULL;
9248 }
9249
9250
9251 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9252 PyObject *resultobj;
9253 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9254 wxFileSystem *arg2 = 0 ;
9255 wxString *arg3 = 0 ;
9256 wxFSFile *result;
9257 bool temp3 = false ;
9258 PyObject * obj0 = 0 ;
9259 PyObject * obj1 = 0 ;
9260 PyObject * obj2 = 0 ;
9261 char *kwnames[] = {
9262 (char *) "self",(char *) "fs",(char *) "location", NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9267 if (SWIG_arg_fail(1)) SWIG_fail;
9268 {
9269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9270 if (SWIG_arg_fail(2)) SWIG_fail;
9271 if (arg2 == NULL) {
9272 SWIG_null_ref("wxFileSystem");
9273 }
9274 if (SWIG_arg_fail(2)) SWIG_fail;
9275 }
9276 {
9277 arg3 = wxString_in_helper(obj2);
9278 if (arg3 == NULL) SWIG_fail;
9279 temp3 = true;
9280 }
9281 {
9282 PyThreadState* __tstate = wxPyBeginAllowThreads();
9283 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9284
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 {
9289 resultobj = wxPyMake_wxObject(result, 1);
9290 }
9291 {
9292 if (temp3)
9293 delete arg3;
9294 }
9295 return resultobj;
9296 fail:
9297 {
9298 if (temp3)
9299 delete arg3;
9300 }
9301 return NULL;
9302 }
9303
9304
9305 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9306 PyObject *obj;
9307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9308 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9309 Py_INCREF(obj);
9310 return Py_BuildValue((char *)"");
9311 }
9312 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj;
9314 wxZipFSHandler *result;
9315 char *kwnames[] = {
9316 NULL
9317 };
9318
9319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (wxZipFSHandler *)new wxZipFSHandler();
9323
9324 wxPyEndAllowThreads(__tstate);
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9335 PyObject *resultobj;
9336 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9337 wxString *arg2 = 0 ;
9338 bool result;
9339 bool temp2 = false ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 char *kwnames[] = {
9343 (char *) "self",(char *) "location", NULL
9344 };
9345
9346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9348 if (SWIG_arg_fail(1)) SWIG_fail;
9349 {
9350 arg2 = wxString_in_helper(obj1);
9351 if (arg2 == NULL) SWIG_fail;
9352 temp2 = true;
9353 }
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9357
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 {
9362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9363 }
9364 {
9365 if (temp2)
9366 delete arg2;
9367 }
9368 return resultobj;
9369 fail:
9370 {
9371 if (temp2)
9372 delete arg2;
9373 }
9374 return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9381 wxFileSystem *arg2 = 0 ;
9382 wxString *arg3 = 0 ;
9383 wxFSFile *result;
9384 bool temp3 = false ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 PyObject * obj2 = 0 ;
9388 char *kwnames[] = {
9389 (char *) "self",(char *) "fs",(char *) "location", NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9394 if (SWIG_arg_fail(1)) SWIG_fail;
9395 {
9396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9397 if (SWIG_arg_fail(2)) SWIG_fail;
9398 if (arg2 == NULL) {
9399 SWIG_null_ref("wxFileSystem");
9400 }
9401 if (SWIG_arg_fail(2)) SWIG_fail;
9402 }
9403 {
9404 arg3 = wxString_in_helper(obj2);
9405 if (arg3 == NULL) SWIG_fail;
9406 temp3 = true;
9407 }
9408 {
9409 PyThreadState* __tstate = wxPyBeginAllowThreads();
9410 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9411
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 {
9416 resultobj = wxPyMake_wxObject(result, 1);
9417 }
9418 {
9419 if (temp3)
9420 delete arg3;
9421 }
9422 return resultobj;
9423 fail:
9424 {
9425 if (temp3)
9426 delete arg3;
9427 }
9428 return NULL;
9429 }
9430
9431
9432 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9433 PyObject *resultobj;
9434 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9435 wxString *arg2 = 0 ;
9436 int arg3 = (int) 0 ;
9437 wxString result;
9438 bool temp2 = false ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 PyObject * obj2 = 0 ;
9442 char *kwnames[] = {
9443 (char *) "self",(char *) "spec",(char *) "flags", NULL
9444 };
9445
9446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9448 if (SWIG_arg_fail(1)) SWIG_fail;
9449 {
9450 arg2 = wxString_in_helper(obj1);
9451 if (arg2 == NULL) SWIG_fail;
9452 temp2 = true;
9453 }
9454 if (obj2) {
9455 {
9456 arg3 = (int)(SWIG_As_int(obj2));
9457 if (SWIG_arg_fail(3)) SWIG_fail;
9458 }
9459 }
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9463
9464 wxPyEndAllowThreads(__tstate);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 {
9468 #if wxUSE_UNICODE
9469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9470 #else
9471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9472 #endif
9473 }
9474 {
9475 if (temp2)
9476 delete arg2;
9477 }
9478 return resultobj;
9479 fail:
9480 {
9481 if (temp2)
9482 delete arg2;
9483 }
9484 return NULL;
9485 }
9486
9487
9488 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj;
9490 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9491 wxString result;
9492 PyObject * obj0 = 0 ;
9493 char *kwnames[] = {
9494 (char *) "self", NULL
9495 };
9496
9497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9499 if (SWIG_arg_fail(1)) SWIG_fail;
9500 {
9501 PyThreadState* __tstate = wxPyBeginAllowThreads();
9502 result = (arg1)->FindNext();
9503
9504 wxPyEndAllowThreads(__tstate);
9505 if (PyErr_Occurred()) SWIG_fail;
9506 }
9507 {
9508 #if wxUSE_UNICODE
9509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9510 #else
9511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9512 #endif
9513 }
9514 return resultobj;
9515 fail:
9516 return NULL;
9517 }
9518
9519
9520 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9521 PyObject *obj;
9522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9523 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9524 Py_INCREF(obj);
9525 return Py_BuildValue((char *)"");
9526 }
9527 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj;
9529 wxString *arg1 = 0 ;
9530 wxImage *arg2 = 0 ;
9531 long arg3 ;
9532 bool temp1 = false ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 PyObject * obj2 = 0 ;
9536 char *kwnames[] = {
9537 (char *) "filename",(char *) "image",(char *) "type", NULL
9538 };
9539
9540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9541 {
9542 arg1 = wxString_in_helper(obj0);
9543 if (arg1 == NULL) SWIG_fail;
9544 temp1 = true;
9545 }
9546 {
9547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9548 if (SWIG_arg_fail(2)) SWIG_fail;
9549 if (arg2 == NULL) {
9550 SWIG_null_ref("wxImage");
9551 }
9552 if (SWIG_arg_fail(2)) SWIG_fail;
9553 }
9554 {
9555 arg3 = (long)(SWIG_As_long(obj2));
9556 if (SWIG_arg_fail(3)) SWIG_fail;
9557 }
9558 {
9559 PyThreadState* __tstate = wxPyBeginAllowThreads();
9560 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9561
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 Py_INCREF(Py_None); resultobj = Py_None;
9566 {
9567 if (temp1)
9568 delete arg1;
9569 }
9570 return resultobj;
9571 fail:
9572 {
9573 if (temp1)
9574 delete arg1;
9575 }
9576 return NULL;
9577 }
9578
9579
9580 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj;
9582 wxString *arg1 = 0 ;
9583 wxBitmap *arg2 = 0 ;
9584 long arg3 ;
9585 bool temp1 = false ;
9586 PyObject * obj0 = 0 ;
9587 PyObject * obj1 = 0 ;
9588 PyObject * obj2 = 0 ;
9589 char *kwnames[] = {
9590 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9591 };
9592
9593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9594 {
9595 arg1 = wxString_in_helper(obj0);
9596 if (arg1 == NULL) SWIG_fail;
9597 temp1 = true;
9598 }
9599 {
9600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9601 if (SWIG_arg_fail(2)) SWIG_fail;
9602 if (arg2 == NULL) {
9603 SWIG_null_ref("wxBitmap");
9604 }
9605 if (SWIG_arg_fail(2)) SWIG_fail;
9606 }
9607 {
9608 arg3 = (long)(SWIG_As_long(obj2));
9609 if (SWIG_arg_fail(3)) SWIG_fail;
9610 }
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
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___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj;
9635 wxString *arg1 = 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 bool temp1 = false ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 char *kwnames[] = {
9641 (char *) "filename",(char *) "data", NULL
9642 };
9643
9644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9645 {
9646 arg1 = wxString_in_helper(obj0);
9647 if (arg1 == NULL) SWIG_fail;
9648 temp1 = true;
9649 }
9650 arg2 = obj1;
9651 {
9652 PyThreadState* __tstate = wxPyBeginAllowThreads();
9653 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9654
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 Py_INCREF(Py_None); resultobj = Py_None;
9659 {
9660 if (temp1)
9661 delete arg1;
9662 }
9663 return resultobj;
9664 fail:
9665 {
9666 if (temp1)
9667 delete arg1;
9668 }
9669 return NULL;
9670 }
9671
9672
9673 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj;
9675 wxMemoryFSHandler *result;
9676 char *kwnames[] = {
9677 NULL
9678 };
9679
9680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj;
9697 wxString *arg1 = 0 ;
9698 bool temp1 = false ;
9699 PyObject * obj0 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "filename", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9705 {
9706 arg1 = wxString_in_helper(obj0);
9707 if (arg1 == NULL) SWIG_fail;
9708 temp1 = true;
9709 }
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9713
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 Py_INCREF(Py_None); resultobj = Py_None;
9718 {
9719 if (temp1)
9720 delete arg1;
9721 }
9722 return resultobj;
9723 fail:
9724 {
9725 if (temp1)
9726 delete arg1;
9727 }
9728 return NULL;
9729 }
9730
9731
9732 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9733 PyObject *resultobj;
9734 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9735 wxString *arg2 = 0 ;
9736 bool result;
9737 bool temp2 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self",(char *) "location", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 {
9748 arg2 = wxString_in_helper(obj1);
9749 if (arg2 == NULL) SWIG_fail;
9750 temp2 = true;
9751 }
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9761 }
9762 {
9763 if (temp2)
9764 delete arg2;
9765 }
9766 return resultobj;
9767 fail:
9768 {
9769 if (temp2)
9770 delete arg2;
9771 }
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9779 wxFileSystem *arg2 = 0 ;
9780 wxString *arg3 = 0 ;
9781 wxFSFile *result;
9782 bool temp3 = false ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "self",(char *) "fs",(char *) "location", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(1)) SWIG_fail;
9793 {
9794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9795 if (SWIG_arg_fail(2)) SWIG_fail;
9796 if (arg2 == NULL) {
9797 SWIG_null_ref("wxFileSystem");
9798 }
9799 if (SWIG_arg_fail(2)) SWIG_fail;
9800 }
9801 {
9802 arg3 = wxString_in_helper(obj2);
9803 if (arg3 == NULL) SWIG_fail;
9804 temp3 = true;
9805 }
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9809
9810 wxPyEndAllowThreads(__tstate);
9811 if (PyErr_Occurred()) SWIG_fail;
9812 }
9813 {
9814 resultobj = wxPyMake_wxObject(result, 1);
9815 }
9816 {
9817 if (temp3)
9818 delete arg3;
9819 }
9820 return resultobj;
9821 fail:
9822 {
9823 if (temp3)
9824 delete arg3;
9825 }
9826 return NULL;
9827 }
9828
9829
9830 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9831 PyObject *resultobj;
9832 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9833 wxString *arg2 = 0 ;
9834 int arg3 = (int) 0 ;
9835 wxString result;
9836 bool temp2 = false ;
9837 PyObject * obj0 = 0 ;
9838 PyObject * obj1 = 0 ;
9839 PyObject * obj2 = 0 ;
9840 char *kwnames[] = {
9841 (char *) "self",(char *) "spec",(char *) "flags", NULL
9842 };
9843
9844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9846 if (SWIG_arg_fail(1)) SWIG_fail;
9847 {
9848 arg2 = wxString_in_helper(obj1);
9849 if (arg2 == NULL) SWIG_fail;
9850 temp2 = true;
9851 }
9852 if (obj2) {
9853 {
9854 arg3 = (int)(SWIG_As_int(obj2));
9855 if (SWIG_arg_fail(3)) SWIG_fail;
9856 }
9857 }
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9861
9862 wxPyEndAllowThreads(__tstate);
9863 if (PyErr_Occurred()) SWIG_fail;
9864 }
9865 {
9866 #if wxUSE_UNICODE
9867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9868 #else
9869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9870 #endif
9871 }
9872 {
9873 if (temp2)
9874 delete arg2;
9875 }
9876 return resultobj;
9877 fail:
9878 {
9879 if (temp2)
9880 delete arg2;
9881 }
9882 return NULL;
9883 }
9884
9885
9886 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj;
9888 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9889 wxString result;
9890 PyObject * obj0 = 0 ;
9891 char *kwnames[] = {
9892 (char *) "self", NULL
9893 };
9894
9895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9897 if (SWIG_arg_fail(1)) SWIG_fail;
9898 {
9899 PyThreadState* __tstate = wxPyBeginAllowThreads();
9900 result = (arg1)->FindNext();
9901
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 {
9906 #if wxUSE_UNICODE
9907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9908 #else
9909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9910 #endif
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9919 PyObject *obj;
9920 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9921 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9922 Py_INCREF(obj);
9923 return Py_BuildValue((char *)"");
9924 }
9925 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9926 PyObject *resultobj;
9927 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9928 wxString result;
9929 PyObject * obj0 = 0 ;
9930 char *kwnames[] = {
9931 (char *) "self", NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9936 if (SWIG_arg_fail(1)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (arg1)->GetName();
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 {
9945 #if wxUSE_UNICODE
9946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9947 #else
9948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9949 #endif
9950 }
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj;
9959 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9960 wxString result;
9961 PyObject * obj0 = 0 ;
9962 char *kwnames[] = {
9963 (char *) "self", NULL
9964 };
9965
9966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9968 if (SWIG_arg_fail(1)) SWIG_fail;
9969 {
9970 PyThreadState* __tstate = wxPyBeginAllowThreads();
9971 result = (arg1)->GetExtension();
9972
9973 wxPyEndAllowThreads(__tstate);
9974 if (PyErr_Occurred()) SWIG_fail;
9975 }
9976 {
9977 #if wxUSE_UNICODE
9978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9979 #else
9980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9981 #endif
9982 }
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj;
9991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9992 long result;
9993 PyObject * obj0 = 0 ;
9994 char *kwnames[] = {
9995 (char *) "self", NULL
9996 };
9997
9998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10000 if (SWIG_arg_fail(1)) SWIG_fail;
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (long)(arg1)->GetType();
10004
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 resultobj = SWIG_From_long((long)(result));
10010 }
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10018 PyObject *resultobj;
10019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10020 wxString result;
10021 PyObject * obj0 = 0 ;
10022 char *kwnames[] = {
10023 (char *) "self", NULL
10024 };
10025
10026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10028 if (SWIG_arg_fail(1)) SWIG_fail;
10029 {
10030 PyThreadState* __tstate = wxPyBeginAllowThreads();
10031 result = (arg1)->GetMimeType();
10032
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 {
10037 #if wxUSE_UNICODE
10038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10039 #else
10040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10041 #endif
10042 }
10043 return resultobj;
10044 fail:
10045 return NULL;
10046 }
10047
10048
10049 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj;
10051 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10052 wxString *arg2 = 0 ;
10053 bool result;
10054 bool temp2 = false ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 char *kwnames[] = {
10058 (char *) "self",(char *) "name", NULL
10059 };
10060
10061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10063 if (SWIG_arg_fail(1)) SWIG_fail;
10064 {
10065 arg2 = wxString_in_helper(obj1);
10066 if (arg2 == NULL) SWIG_fail;
10067 temp2 = true;
10068 }
10069 {
10070 PyThreadState* __tstate = wxPyBeginAllowThreads();
10071 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10072
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 {
10077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10078 }
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj;
10095 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10096 wxString *arg2 = 0 ;
10097 bool temp2 = false ;
10098 PyObject * obj0 = 0 ;
10099 PyObject * obj1 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "self",(char *) "name", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10106 if (SWIG_arg_fail(1)) SWIG_fail;
10107 {
10108 arg2 = wxString_in_helper(obj1);
10109 if (arg2 == NULL) SWIG_fail;
10110 temp2 = true;
10111 }
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 (arg1)->SetName((wxString const &)*arg2);
10115
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 Py_INCREF(Py_None); resultobj = Py_None;
10120 {
10121 if (temp2)
10122 delete arg2;
10123 }
10124 return resultobj;
10125 fail:
10126 {
10127 if (temp2)
10128 delete arg2;
10129 }
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10137 wxString *arg2 = 0 ;
10138 bool temp2 = false ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char *kwnames[] = {
10142 (char *) "self",(char *) "extension", NULL
10143 };
10144
10145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10147 if (SWIG_arg_fail(1)) SWIG_fail;
10148 {
10149 arg2 = wxString_in_helper(obj1);
10150 if (arg2 == NULL) SWIG_fail;
10151 temp2 = true;
10152 }
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 (arg1)->SetExtension((wxString const &)*arg2);
10156
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 Py_INCREF(Py_None); resultobj = Py_None;
10161 {
10162 if (temp2)
10163 delete arg2;
10164 }
10165 return resultobj;
10166 fail:
10167 {
10168 if (temp2)
10169 delete arg2;
10170 }
10171 return NULL;
10172 }
10173
10174
10175 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10176 PyObject *resultobj;
10177 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10178 long arg2 ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 char *kwnames[] = {
10182 (char *) "self",(char *) "type", NULL
10183 };
10184
10185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10187 if (SWIG_arg_fail(1)) SWIG_fail;
10188 {
10189 arg2 = (long)(SWIG_As_long(obj1));
10190 if (SWIG_arg_fail(2)) SWIG_fail;
10191 }
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 (arg1)->SetType(arg2);
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 Py_INCREF(Py_None); resultobj = Py_None;
10200 return resultobj;
10201 fail:
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10209 wxString *arg2 = 0 ;
10210 bool temp2 = false ;
10211 PyObject * obj0 = 0 ;
10212 PyObject * obj1 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "self",(char *) "mimetype", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10219 if (SWIG_arg_fail(1)) SWIG_fail;
10220 {
10221 arg2 = wxString_in_helper(obj1);
10222 if (arg2 == NULL) SWIG_fail;
10223 temp2 = true;
10224 }
10225 {
10226 PyThreadState* __tstate = wxPyBeginAllowThreads();
10227 (arg1)->SetMimeType((wxString const &)*arg2);
10228
10229 wxPyEndAllowThreads(__tstate);
10230 if (PyErr_Occurred()) SWIG_fail;
10231 }
10232 Py_INCREF(Py_None); resultobj = Py_None;
10233 {
10234 if (temp2)
10235 delete arg2;
10236 }
10237 return resultobj;
10238 fail:
10239 {
10240 if (temp2)
10241 delete arg2;
10242 }
10243 return NULL;
10244 }
10245
10246
10247 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10248 PyObject *obj;
10249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10250 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10251 Py_INCREF(obj);
10252 return Py_BuildValue((char *)"");
10253 }
10254 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10255 PyObject *resultobj;
10256 wxPyImageHandler *result;
10257 char *kwnames[] = {
10258 NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 result = (wxPyImageHandler *)new wxPyImageHandler();
10265
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10270 return resultobj;
10271 fail:
10272 return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10277 PyObject *resultobj;
10278 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10279 PyObject *arg2 = (PyObject *) 0 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 char *kwnames[] = {
10283 (char *) "self",(char *) "self", NULL
10284 };
10285
10286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10288 if (SWIG_arg_fail(1)) SWIG_fail;
10289 arg2 = obj1;
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 (arg1)->_SetSelf(arg2);
10293
10294 wxPyEndAllowThreads(__tstate);
10295 if (PyErr_Occurred()) SWIG_fail;
10296 }
10297 Py_INCREF(Py_None); resultobj = Py_None;
10298 return resultobj;
10299 fail:
10300 return NULL;
10301 }
10302
10303
10304 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10305 PyObject *obj;
10306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10307 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10308 Py_INCREF(obj);
10309 return Py_BuildValue((char *)"");
10310 }
10311 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10312 PyObject *resultobj;
10313 wxImageHistogram *result;
10314 char *kwnames[] = {
10315 NULL
10316 };
10317
10318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10319 {
10320 PyThreadState* __tstate = wxPyBeginAllowThreads();
10321 result = (wxImageHistogram *)new wxImageHistogram();
10322
10323 wxPyEndAllowThreads(__tstate);
10324 if (PyErr_Occurred()) SWIG_fail;
10325 }
10326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10327 return resultobj;
10328 fail:
10329 return NULL;
10330 }
10331
10332
10333 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10334 PyObject *resultobj;
10335 byte arg1 ;
10336 byte arg2 ;
10337 byte arg3 ;
10338 unsigned long result;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 PyObject * obj2 = 0 ;
10342 char *kwnames[] = {
10343 (char *) "r",(char *) "g",(char *) "b", NULL
10344 };
10345
10346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10347 {
10348 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10349 if (SWIG_arg_fail(1)) SWIG_fail;
10350 }
10351 {
10352 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10353 if (SWIG_arg_fail(2)) SWIG_fail;
10354 }
10355 {
10356 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10357 if (SWIG_arg_fail(3)) SWIG_fail;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10368 }
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj;
10377 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10378 byte *arg2 = (byte *) 0 ;
10379 byte *arg3 = (byte *) 0 ;
10380 byte *arg4 = (byte *) 0 ;
10381 byte arg5 = (byte) 1 ;
10382 byte arg6 = (byte) 0 ;
10383 byte arg7 = (byte) 0 ;
10384 bool result;
10385 byte temp2 ;
10386 int res2 = 0 ;
10387 byte temp3 ;
10388 int res3 = 0 ;
10389 byte temp4 ;
10390 int res4 = 0 ;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 PyObject * obj3 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10397 };
10398
10399 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10400 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10401 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10404 if (SWIG_arg_fail(1)) SWIG_fail;
10405 if (obj1) {
10406 {
10407 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10408 if (SWIG_arg_fail(5)) SWIG_fail;
10409 }
10410 }
10411 if (obj2) {
10412 {
10413 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10414 if (SWIG_arg_fail(6)) SWIG_fail;
10415 }
10416 }
10417 if (obj3) {
10418 {
10419 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10420 if (SWIG_arg_fail(7)) SWIG_fail;
10421 }
10422 }
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10426
10427 wxPyEndAllowThreads(__tstate);
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 {
10431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10432 }
10433 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10434 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10435 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10436 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10437 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10438 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10439 return resultobj;
10440 fail:
10441 return NULL;
10442 }
10443
10444
10445 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj;
10447 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10448 unsigned long arg2 ;
10449 unsigned long result;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 char *kwnames[] = {
10453 (char *) "self",(char *) "key", NULL
10454 };
10455
10456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10458 if (SWIG_arg_fail(1)) SWIG_fail;
10459 {
10460 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10461 if (SWIG_arg_fail(2)) SWIG_fail;
10462 }
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10466
10467 wxPyEndAllowThreads(__tstate);
10468 if (PyErr_Occurred()) SWIG_fail;
10469 }
10470 {
10471 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10472 }
10473 return resultobj;
10474 fail:
10475 return NULL;
10476 }
10477
10478
10479 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10480 PyObject *resultobj;
10481 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10482 byte arg2 ;
10483 byte arg3 ;
10484 byte arg4 ;
10485 unsigned long result;
10486 PyObject * obj0 = 0 ;
10487 PyObject * obj1 = 0 ;
10488 PyObject * obj2 = 0 ;
10489 PyObject * obj3 = 0 ;
10490 char *kwnames[] = {
10491 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10492 };
10493
10494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10496 if (SWIG_arg_fail(1)) SWIG_fail;
10497 {
10498 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10499 if (SWIG_arg_fail(2)) SWIG_fail;
10500 }
10501 {
10502 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10503 if (SWIG_arg_fail(3)) SWIG_fail;
10504 }
10505 {
10506 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10507 if (SWIG_arg_fail(4)) SWIG_fail;
10508 }
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10512
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10518 }
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10526 PyObject *resultobj;
10527 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10528 wxColour *arg2 = 0 ;
10529 unsigned long result;
10530 wxColour temp2 ;
10531 PyObject * obj0 = 0 ;
10532 PyObject * obj1 = 0 ;
10533 char *kwnames[] = {
10534 (char *) "self",(char *) "colour", NULL
10535 };
10536
10537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10539 if (SWIG_arg_fail(1)) SWIG_fail;
10540 {
10541 arg2 = &temp2;
10542 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10543 }
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10547
10548 wxPyEndAllowThreads(__tstate);
10549 if (PyErr_Occurred()) SWIG_fail;
10550 }
10551 {
10552 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10553 }
10554 return resultobj;
10555 fail:
10556 return NULL;
10557 }
10558
10559
10560 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10561 PyObject *obj;
10562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10563 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10564 Py_INCREF(obj);
10565 return Py_BuildValue((char *)"");
10566 }
10567 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10568 PyObject *resultobj;
10569 byte arg1 = (byte) 0 ;
10570 byte arg2 = (byte) 0 ;
10571 byte arg3 = (byte) 0 ;
10572 wxImage_RGBValue *result;
10573 PyObject * obj0 = 0 ;
10574 PyObject * obj1 = 0 ;
10575 PyObject * obj2 = 0 ;
10576 char *kwnames[] = {
10577 (char *) "r",(char *) "g",(char *) "b", NULL
10578 };
10579
10580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10581 if (obj0) {
10582 {
10583 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10584 if (SWIG_arg_fail(1)) SWIG_fail;
10585 }
10586 }
10587 if (obj1) {
10588 {
10589 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10590 if (SWIG_arg_fail(2)) SWIG_fail;
10591 }
10592 }
10593 if (obj2) {
10594 {
10595 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10596 if (SWIG_arg_fail(3)) SWIG_fail;
10597 }
10598 }
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10602
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10607 return resultobj;
10608 fail:
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10616 byte arg2 ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 char *kwnames[] = {
10620 (char *) "self",(char *) "red", NULL
10621 };
10622
10623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10625 if (SWIG_arg_fail(1)) SWIG_fail;
10626 {
10627 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10628 if (SWIG_arg_fail(2)) SWIG_fail;
10629 }
10630 if (arg1) (arg1)->red = arg2;
10631
10632 Py_INCREF(Py_None); resultobj = Py_None;
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj;
10641 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10642 byte result;
10643 PyObject * obj0 = 0 ;
10644 char *kwnames[] = {
10645 (char *) "self", NULL
10646 };
10647
10648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10650 if (SWIG_arg_fail(1)) SWIG_fail;
10651 result = (byte) ((arg1)->red);
10652
10653 {
10654 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10655 }
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10663 PyObject *resultobj;
10664 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10665 byte arg2 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char *kwnames[] = {
10669 (char *) "self",(char *) "green", NULL
10670 };
10671
10672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10674 if (SWIG_arg_fail(1)) SWIG_fail;
10675 {
10676 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10677 if (SWIG_arg_fail(2)) SWIG_fail;
10678 }
10679 if (arg1) (arg1)->green = arg2;
10680
10681 Py_INCREF(Py_None); resultobj = Py_None;
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10689 PyObject *resultobj;
10690 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10691 byte result;
10692 PyObject * obj0 = 0 ;
10693 char *kwnames[] = {
10694 (char *) "self", NULL
10695 };
10696
10697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10699 if (SWIG_arg_fail(1)) SWIG_fail;
10700 result = (byte) ((arg1)->green);
10701
10702 {
10703 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10704 }
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10712 PyObject *resultobj;
10713 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10714 byte arg2 ;
10715 PyObject * obj0 = 0 ;
10716 PyObject * obj1 = 0 ;
10717 char *kwnames[] = {
10718 (char *) "self",(char *) "blue", NULL
10719 };
10720
10721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10723 if (SWIG_arg_fail(1)) SWIG_fail;
10724 {
10725 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10726 if (SWIG_arg_fail(2)) SWIG_fail;
10727 }
10728 if (arg1) (arg1)->blue = arg2;
10729
10730 Py_INCREF(Py_None); resultobj = Py_None;
10731 return resultobj;
10732 fail:
10733 return NULL;
10734 }
10735
10736
10737 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10738 PyObject *resultobj;
10739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10740 byte result;
10741 PyObject * obj0 = 0 ;
10742 char *kwnames[] = {
10743 (char *) "self", NULL
10744 };
10745
10746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10748 if (SWIG_arg_fail(1)) SWIG_fail;
10749 result = (byte) ((arg1)->blue);
10750
10751 {
10752 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10753 }
10754 return resultobj;
10755 fail:
10756 return NULL;
10757 }
10758
10759
10760 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10761 PyObject *obj;
10762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10763 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10764 Py_INCREF(obj);
10765 return Py_BuildValue((char *)"");
10766 }
10767 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj;
10769 double arg1 = (double) 0.0 ;
10770 double arg2 = (double) 0.0 ;
10771 double arg3 = (double) 0.0 ;
10772 wxImage_HSVValue *result;
10773 PyObject * obj0 = 0 ;
10774 PyObject * obj1 = 0 ;
10775 PyObject * obj2 = 0 ;
10776 char *kwnames[] = {
10777 (char *) "h",(char *) "s",(char *) "v", NULL
10778 };
10779
10780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10781 if (obj0) {
10782 {
10783 arg1 = (double)(SWIG_As_double(obj0));
10784 if (SWIG_arg_fail(1)) SWIG_fail;
10785 }
10786 }
10787 if (obj1) {
10788 {
10789 arg2 = (double)(SWIG_As_double(obj1));
10790 if (SWIG_arg_fail(2)) SWIG_fail;
10791 }
10792 }
10793 if (obj2) {
10794 {
10795 arg3 = (double)(SWIG_As_double(obj2));
10796 if (SWIG_arg_fail(3)) SWIG_fail;
10797 }
10798 }
10799 {
10800 PyThreadState* __tstate = wxPyBeginAllowThreads();
10801 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10802
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj;
10815 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10816 double arg2 ;
10817 PyObject * obj0 = 0 ;
10818 PyObject * obj1 = 0 ;
10819 char *kwnames[] = {
10820 (char *) "self",(char *) "hue", NULL
10821 };
10822
10823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 {
10827 arg2 = (double)(SWIG_As_double(obj1));
10828 if (SWIG_arg_fail(2)) SWIG_fail;
10829 }
10830 if (arg1) (arg1)->hue = arg2;
10831
10832 Py_INCREF(Py_None); resultobj = Py_None;
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj;
10841 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10842 double result;
10843 PyObject * obj0 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "self", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10850 if (SWIG_arg_fail(1)) SWIG_fail;
10851 result = (double) ((arg1)->hue);
10852
10853 {
10854 resultobj = SWIG_From_double((double)(result));
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj;
10864 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10865 double arg2 ;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 char *kwnames[] = {
10869 (char *) "self",(char *) "saturation", NULL
10870 };
10871
10872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10874 if (SWIG_arg_fail(1)) SWIG_fail;
10875 {
10876 arg2 = (double)(SWIG_As_double(obj1));
10877 if (SWIG_arg_fail(2)) SWIG_fail;
10878 }
10879 if (arg1) (arg1)->saturation = arg2;
10880
10881 Py_INCREF(Py_None); resultobj = Py_None;
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10891 double result;
10892 PyObject * obj0 = 0 ;
10893 char *kwnames[] = {
10894 (char *) "self", NULL
10895 };
10896
10897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10899 if (SWIG_arg_fail(1)) SWIG_fail;
10900 result = (double) ((arg1)->saturation);
10901
10902 {
10903 resultobj = SWIG_From_double((double)(result));
10904 }
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj;
10913 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10914 double arg2 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 char *kwnames[] = {
10918 (char *) "self",(char *) "value", NULL
10919 };
10920
10921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
10922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10923 if (SWIG_arg_fail(1)) SWIG_fail;
10924 {
10925 arg2 = (double)(SWIG_As_double(obj1));
10926 if (SWIG_arg_fail(2)) SWIG_fail;
10927 }
10928 if (arg1) (arg1)->value = arg2;
10929
10930 Py_INCREF(Py_None); resultobj = Py_None;
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj;
10939 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10940 double result;
10941 PyObject * obj0 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 result = (double) ((arg1)->value);
10950
10951 {
10952 resultobj = SWIG_From_double((double)(result));
10953 }
10954 return resultobj;
10955 fail:
10956 return NULL;
10957 }
10958
10959
10960 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
10961 PyObject *obj;
10962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10963 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
10964 Py_INCREF(obj);
10965 return Py_BuildValue((char *)"");
10966 }
10967 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxString *arg1 = 0 ;
10970 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10971 int arg3 = (int) -1 ;
10972 wxImage *result;
10973 bool temp1 = false ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 PyObject * obj2 = 0 ;
10977 char *kwnames[] = {
10978 (char *) "name",(char *) "type",(char *) "index", NULL
10979 };
10980
10981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10982 {
10983 arg1 = wxString_in_helper(obj0);
10984 if (arg1 == NULL) SWIG_fail;
10985 temp1 = true;
10986 }
10987 if (obj1) {
10988 {
10989 arg2 = (long)(SWIG_As_long(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 }
10993 if (obj2) {
10994 {
10995 arg3 = (int)(SWIG_As_int(obj2));
10996 if (SWIG_arg_fail(3)) SWIG_fail;
10997 }
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11002
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11007 {
11008 if (temp1)
11009 delete arg1;
11010 }
11011 return resultobj;
11012 fail:
11013 {
11014 if (temp1)
11015 delete arg1;
11016 }
11017 return NULL;
11018 }
11019
11020
11021 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11022 PyObject *resultobj;
11023 wxImage *arg1 = (wxImage *) 0 ;
11024 PyObject * obj0 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 delete arg1;
11035
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 Py_INCREF(Py_None); resultobj = Py_None;
11040 return resultobj;
11041 fail:
11042 return NULL;
11043 }
11044
11045
11046 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11047 PyObject *resultobj;
11048 wxString *arg1 = 0 ;
11049 wxString *arg2 = 0 ;
11050 int arg3 = (int) -1 ;
11051 wxImage *result;
11052 bool temp1 = false ;
11053 bool temp2 = false ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 char *kwnames[] = {
11058 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11059 };
11060
11061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11062 {
11063 arg1 = wxString_in_helper(obj0);
11064 if (arg1 == NULL) SWIG_fail;
11065 temp1 = true;
11066 }
11067 {
11068 arg2 = wxString_in_helper(obj1);
11069 if (arg2 == NULL) SWIG_fail;
11070 temp2 = true;
11071 }
11072 if (obj2) {
11073 {
11074 arg3 = (int)(SWIG_As_int(obj2));
11075 if (SWIG_arg_fail(3)) SWIG_fail;
11076 }
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11081
11082 wxPyEndAllowThreads(__tstate);
11083 if (PyErr_Occurred()) SWIG_fail;
11084 }
11085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11086 {
11087 if (temp1)
11088 delete arg1;
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp1)
11098 delete arg1;
11099 }
11100 {
11101 if (temp2)
11102 delete arg2;
11103 }
11104 return NULL;
11105 }
11106
11107
11108 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11109 PyObject *resultobj;
11110 wxInputStream *arg1 = 0 ;
11111 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11112 int arg3 = (int) -1 ;
11113 wxImage *result;
11114 wxPyInputStream *temp1 ;
11115 bool created1 ;
11116 PyObject * obj0 = 0 ;
11117 PyObject * obj1 = 0 ;
11118 PyObject * obj2 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "stream",(char *) "type",(char *) "index", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11124 {
11125 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11126 arg1 = temp1->m_wxis;
11127 created1 = false;
11128 } else {
11129 PyErr_Clear(); // clear the failure of the wxPyConvert above
11130 arg1 = wxPyCBInputStream_create(obj0, false);
11131 if (arg1 == NULL) {
11132 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11133 SWIG_fail;
11134 }
11135 created1 = true;
11136 }
11137 }
11138 if (obj1) {
11139 {
11140 arg2 = (long)(SWIG_As_long(obj1));
11141 if (SWIG_arg_fail(2)) SWIG_fail;
11142 }
11143 }
11144 if (obj2) {
11145 {
11146 arg3 = (int)(SWIG_As_int(obj2));
11147 if (SWIG_arg_fail(3)) SWIG_fail;
11148 }
11149 }
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11158 {
11159 if (created1) delete arg1;
11160 }
11161 return resultobj;
11162 fail:
11163 {
11164 if (created1) delete arg1;
11165 }
11166 return NULL;
11167 }
11168
11169
11170 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11171 PyObject *resultobj;
11172 wxInputStream *arg1 = 0 ;
11173 wxString *arg2 = 0 ;
11174 int arg3 = (int) -1 ;
11175 wxImage *result;
11176 wxPyInputStream *temp1 ;
11177 bool created1 ;
11178 bool temp2 = false ;
11179 PyObject * obj0 = 0 ;
11180 PyObject * obj1 = 0 ;
11181 PyObject * obj2 = 0 ;
11182 char *kwnames[] = {
11183 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11184 };
11185
11186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11187 {
11188 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11189 arg1 = temp1->m_wxis;
11190 created1 = false;
11191 } else {
11192 PyErr_Clear(); // clear the failure of the wxPyConvert above
11193 arg1 = wxPyCBInputStream_create(obj0, false);
11194 if (arg1 == NULL) {
11195 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11196 SWIG_fail;
11197 }
11198 created1 = true;
11199 }
11200 }
11201 {
11202 arg2 = wxString_in_helper(obj1);
11203 if (arg2 == NULL) SWIG_fail;
11204 temp2 = true;
11205 }
11206 if (obj2) {
11207 {
11208 arg3 = (int)(SWIG_As_int(obj2));
11209 if (SWIG_arg_fail(3)) SWIG_fail;
11210 }
11211 }
11212 {
11213 PyThreadState* __tstate = wxPyBeginAllowThreads();
11214 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11215
11216 wxPyEndAllowThreads(__tstate);
11217 if (PyErr_Occurred()) SWIG_fail;
11218 }
11219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11220 {
11221 if (created1) delete arg1;
11222 }
11223 {
11224 if (temp2)
11225 delete arg2;
11226 }
11227 return resultobj;
11228 fail:
11229 {
11230 if (created1) delete arg1;
11231 }
11232 {
11233 if (temp2)
11234 delete arg2;
11235 }
11236 return NULL;
11237 }
11238
11239
11240 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11241 PyObject *resultobj;
11242 int arg1 = (int) 0 ;
11243 int arg2 = (int) 0 ;
11244 bool arg3 = (bool) true ;
11245 wxImage *result;
11246 PyObject * obj0 = 0 ;
11247 PyObject * obj1 = 0 ;
11248 PyObject * obj2 = 0 ;
11249 char *kwnames[] = {
11250 (char *) "width",(char *) "height",(char *) "clear", NULL
11251 };
11252
11253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11254 if (obj0) {
11255 {
11256 arg1 = (int)(SWIG_As_int(obj0));
11257 if (SWIG_arg_fail(1)) SWIG_fail;
11258 }
11259 }
11260 if (obj1) {
11261 {
11262 arg2 = (int)(SWIG_As_int(obj1));
11263 if (SWIG_arg_fail(2)) SWIG_fail;
11264 }
11265 }
11266 if (obj2) {
11267 {
11268 arg3 = (bool)(SWIG_As_bool(obj2));
11269 if (SWIG_arg_fail(3)) SWIG_fail;
11270 }
11271 }
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11275
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11280 return resultobj;
11281 fail:
11282 return NULL;
11283 }
11284
11285
11286 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj;
11288 wxBitmap *arg1 = 0 ;
11289 wxImage *result;
11290 PyObject * obj0 = 0 ;
11291 char *kwnames[] = {
11292 (char *) "bitmap", NULL
11293 };
11294
11295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11296 {
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 if (arg1 == NULL) {
11300 SWIG_null_ref("wxBitmap");
11301 }
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 }
11304 {
11305 if (!wxPyCheckForApp()) SWIG_fail;
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11313 return resultobj;
11314 fail:
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj;
11321 int arg1 ;
11322 int arg2 ;
11323 buffer arg3 ;
11324 int arg4 ;
11325 wxImage *result;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char *kwnames[] = {
11330 (char *) "width",(char *) "height",(char *) "data", NULL
11331 };
11332
11333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11334 {
11335 arg1 = (int)(SWIG_As_int(obj0));
11336 if (SWIG_arg_fail(1)) SWIG_fail;
11337 }
11338 {
11339 arg2 = (int)(SWIG_As_int(obj1));
11340 if (SWIG_arg_fail(2)) SWIG_fail;
11341 }
11342 {
11343 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11344 }
11345 {
11346 PyThreadState* __tstate = wxPyBeginAllowThreads();
11347 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11348
11349 wxPyEndAllowThreads(__tstate);
11350 if (PyErr_Occurred()) SWIG_fail;
11351 }
11352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj;
11361 int arg1 ;
11362 int arg2 ;
11363 buffer arg3 ;
11364 int arg4 ;
11365 buffer arg5 ;
11366 int arg6 ;
11367 wxImage *result;
11368 PyObject * obj0 = 0 ;
11369 PyObject * obj1 = 0 ;
11370 PyObject * obj2 = 0 ;
11371 PyObject * obj3 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11377 {
11378 arg1 = (int)(SWIG_As_int(obj0));
11379 if (SWIG_arg_fail(1)) SWIG_fail;
11380 }
11381 {
11382 arg2 = (int)(SWIG_As_int(obj1));
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11387 }
11388 {
11389 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11406 PyObject *resultobj;
11407 wxImage *arg1 = (wxImage *) 0 ;
11408 int arg2 ;
11409 int arg3 ;
11410 bool arg4 = (bool) true ;
11411 PyObject * obj0 = 0 ;
11412 PyObject * obj1 = 0 ;
11413 PyObject * obj2 = 0 ;
11414 PyObject * obj3 = 0 ;
11415 char *kwnames[] = {
11416 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11417 };
11418
11419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11421 if (SWIG_arg_fail(1)) SWIG_fail;
11422 {
11423 arg2 = (int)(SWIG_As_int(obj1));
11424 if (SWIG_arg_fail(2)) SWIG_fail;
11425 }
11426 {
11427 arg3 = (int)(SWIG_As_int(obj2));
11428 if (SWIG_arg_fail(3)) SWIG_fail;
11429 }
11430 if (obj3) {
11431 {
11432 arg4 = (bool)(SWIG_As_bool(obj3));
11433 if (SWIG_arg_fail(4)) SWIG_fail;
11434 }
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 (arg1)->Create(arg2,arg3,arg4);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxImage *arg1 = (wxImage *) 0 ;
11453 PyObject * obj0 = 0 ;
11454 char *kwnames[] = {
11455 (char *) "self", NULL
11456 };
11457
11458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11460 if (SWIG_arg_fail(1)) SWIG_fail;
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 (arg1)->Destroy();
11464
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 Py_INCREF(Py_None); resultobj = Py_None;
11469 return resultobj;
11470 fail:
11471 return NULL;
11472 }
11473
11474
11475 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj;
11477 wxImage *arg1 = (wxImage *) 0 ;
11478 int arg2 ;
11479 int arg3 ;
11480 SwigValueWrapper<wxImage > result;
11481 PyObject * obj0 = 0 ;
11482 PyObject * obj1 = 0 ;
11483 PyObject * obj2 = 0 ;
11484 char *kwnames[] = {
11485 (char *) "self",(char *) "width",(char *) "height", NULL
11486 };
11487
11488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11490 if (SWIG_arg_fail(1)) SWIG_fail;
11491 {
11492 arg2 = (int)(SWIG_As_int(obj1));
11493 if (SWIG_arg_fail(2)) SWIG_fail;
11494 }
11495 {
11496 arg3 = (int)(SWIG_As_int(obj2));
11497 if (SWIG_arg_fail(3)) SWIG_fail;
11498 }
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (arg1)->Scale(arg2,arg3);
11502
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 wxImage * resultptr;
11508 resultptr = new wxImage((wxImage &)(result));
11509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11510 }
11511 return resultobj;
11512 fail:
11513 return NULL;
11514 }
11515
11516
11517 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11518 PyObject *resultobj;
11519 wxImage *arg1 = (wxImage *) 0 ;
11520 int arg2 ;
11521 int arg3 ;
11522 SwigValueWrapper<wxImage > result;
11523 PyObject * obj0 = 0 ;
11524 PyObject * obj1 = 0 ;
11525 PyObject * obj2 = 0 ;
11526 char *kwnames[] = {
11527 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11528 };
11529
11530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 {
11534 arg2 = (int)(SWIG_As_int(obj1));
11535 if (SWIG_arg_fail(2)) SWIG_fail;
11536 }
11537 {
11538 arg3 = (int)(SWIG_As_int(obj2));
11539 if (SWIG_arg_fail(3)) SWIG_fail;
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 wxImage * resultptr;
11550 resultptr = new wxImage((wxImage &)(result));
11551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11552 }
11553 return resultobj;
11554 fail:
11555 return NULL;
11556 }
11557
11558
11559 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj;
11561 wxImage *arg1 = (wxImage *) 0 ;
11562 int arg2 ;
11563 int arg3 ;
11564 wxImage *result;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 char *kwnames[] = {
11569 (char *) "self",(char *) "width",(char *) "height", NULL
11570 };
11571
11572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11574 if (SWIG_arg_fail(1)) SWIG_fail;
11575 {
11576 arg2 = (int)(SWIG_As_int(obj1));
11577 if (SWIG_arg_fail(2)) SWIG_fail;
11578 }
11579 {
11580 arg3 = (int)(SWIG_As_int(obj2));
11581 if (SWIG_arg_fail(3)) SWIG_fail;
11582 }
11583 {
11584 PyThreadState* __tstate = wxPyBeginAllowThreads();
11585 {
11586 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11587 result = (wxImage *) &_result_ref;
11588 }
11589
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11594 return resultobj;
11595 fail:
11596 return NULL;
11597 }
11598
11599
11600 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11601 PyObject *resultobj;
11602 wxImage *arg1 = (wxImage *) 0 ;
11603 wxSize *arg2 = 0 ;
11604 wxPoint *arg3 = 0 ;
11605 int arg4 = (int) -1 ;
11606 int arg5 = (int) -1 ;
11607 int arg6 = (int) -1 ;
11608 wxImage *result;
11609 wxSize temp2 ;
11610 wxPoint temp3 ;
11611 PyObject * obj0 = 0 ;
11612 PyObject * obj1 = 0 ;
11613 PyObject * obj2 = 0 ;
11614 PyObject * obj3 = 0 ;
11615 PyObject * obj4 = 0 ;
11616 PyObject * obj5 = 0 ;
11617 char *kwnames[] = {
11618 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11619 };
11620
11621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11623 if (SWIG_arg_fail(1)) SWIG_fail;
11624 {
11625 arg2 = &temp2;
11626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11627 }
11628 {
11629 arg3 = &temp3;
11630 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11631 }
11632 if (obj3) {
11633 {
11634 arg4 = (int)(SWIG_As_int(obj3));
11635 if (SWIG_arg_fail(4)) SWIG_fail;
11636 }
11637 }
11638 if (obj4) {
11639 {
11640 arg5 = (int)(SWIG_As_int(obj4));
11641 if (SWIG_arg_fail(5)) SWIG_fail;
11642 }
11643 }
11644 if (obj5) {
11645 {
11646 arg6 = (int)(SWIG_As_int(obj5));
11647 if (SWIG_arg_fail(6)) SWIG_fail;
11648 }
11649 }
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 {
11653 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11654 result = (wxImage *) &_result_ref;
11655 }
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11661 return resultobj;
11662 fail:
11663 return NULL;
11664 }
11665
11666
11667 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj;
11669 wxImage *arg1 = (wxImage *) 0 ;
11670 int arg2 ;
11671 int arg3 ;
11672 byte arg4 ;
11673 byte arg5 ;
11674 byte arg6 ;
11675 PyObject * obj0 = 0 ;
11676 PyObject * obj1 = 0 ;
11677 PyObject * obj2 = 0 ;
11678 PyObject * obj3 = 0 ;
11679 PyObject * obj4 = 0 ;
11680 PyObject * obj5 = 0 ;
11681 char *kwnames[] = {
11682 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11683 };
11684
11685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11687 if (SWIG_arg_fail(1)) SWIG_fail;
11688 {
11689 arg2 = (int)(SWIG_As_int(obj1));
11690 if (SWIG_arg_fail(2)) SWIG_fail;
11691 }
11692 {
11693 arg3 = (int)(SWIG_As_int(obj2));
11694 if (SWIG_arg_fail(3)) SWIG_fail;
11695 }
11696 {
11697 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11698 if (SWIG_arg_fail(4)) SWIG_fail;
11699 }
11700 {
11701 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11702 if (SWIG_arg_fail(5)) SWIG_fail;
11703 }
11704 {
11705 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11706 if (SWIG_arg_fail(6)) SWIG_fail;
11707 }
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11711
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 Py_INCREF(Py_None); resultobj = Py_None;
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11723 PyObject *resultobj;
11724 wxImage *arg1 = (wxImage *) 0 ;
11725 wxRect *arg2 = 0 ;
11726 byte arg3 ;
11727 byte arg4 ;
11728 byte arg5 ;
11729 wxRect temp2 ;
11730 PyObject * obj0 = 0 ;
11731 PyObject * obj1 = 0 ;
11732 PyObject * obj2 = 0 ;
11733 PyObject * obj3 = 0 ;
11734 PyObject * obj4 = 0 ;
11735 char *kwnames[] = {
11736 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11737 };
11738
11739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11741 if (SWIG_arg_fail(1)) SWIG_fail;
11742 {
11743 arg2 = &temp2;
11744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11745 }
11746 {
11747 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11748 if (SWIG_arg_fail(3)) SWIG_fail;
11749 }
11750 {
11751 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11752 if (SWIG_arg_fail(4)) SWIG_fail;
11753 }
11754 {
11755 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11756 if (SWIG_arg_fail(5)) SWIG_fail;
11757 }
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11761
11762 wxPyEndAllowThreads(__tstate);
11763 if (PyErr_Occurred()) SWIG_fail;
11764 }
11765 Py_INCREF(Py_None); resultobj = Py_None;
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj;
11774 wxImage *arg1 = (wxImage *) 0 ;
11775 int arg2 ;
11776 int arg3 ;
11777 byte result;
11778 PyObject * obj0 = 0 ;
11779 PyObject * obj1 = 0 ;
11780 PyObject * obj2 = 0 ;
11781 char *kwnames[] = {
11782 (char *) "self",(char *) "x",(char *) "y", NULL
11783 };
11784
11785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11787 if (SWIG_arg_fail(1)) SWIG_fail;
11788 {
11789 arg2 = (int)(SWIG_As_int(obj1));
11790 if (SWIG_arg_fail(2)) SWIG_fail;
11791 }
11792 {
11793 arg3 = (int)(SWIG_As_int(obj2));
11794 if (SWIG_arg_fail(3)) SWIG_fail;
11795 }
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (byte)(arg1)->GetRed(arg2,arg3);
11799
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 {
11804 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11805 }
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj;
11814 wxImage *arg1 = (wxImage *) 0 ;
11815 int arg2 ;
11816 int arg3 ;
11817 byte result;
11818 PyObject * obj0 = 0 ;
11819 PyObject * obj1 = 0 ;
11820 PyObject * obj2 = 0 ;
11821 char *kwnames[] = {
11822 (char *) "self",(char *) "x",(char *) "y", NULL
11823 };
11824
11825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11827 if (SWIG_arg_fail(1)) SWIG_fail;
11828 {
11829 arg2 = (int)(SWIG_As_int(obj1));
11830 if (SWIG_arg_fail(2)) SWIG_fail;
11831 }
11832 {
11833 arg3 = (int)(SWIG_As_int(obj2));
11834 if (SWIG_arg_fail(3)) SWIG_fail;
11835 }
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (byte)(arg1)->GetGreen(arg2,arg3);
11839
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11845 }
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11853 PyObject *resultobj;
11854 wxImage *arg1 = (wxImage *) 0 ;
11855 int arg2 ;
11856 int arg3 ;
11857 byte result;
11858 PyObject * obj0 = 0 ;
11859 PyObject * obj1 = 0 ;
11860 PyObject * obj2 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self",(char *) "x",(char *) "y", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 {
11869 arg2 = (int)(SWIG_As_int(obj1));
11870 if (SWIG_arg_fail(2)) SWIG_fail;
11871 }
11872 {
11873 arg3 = (int)(SWIG_As_int(obj2));
11874 if (SWIG_arg_fail(3)) SWIG_fail;
11875 }
11876 {
11877 PyThreadState* __tstate = wxPyBeginAllowThreads();
11878 result = (byte)(arg1)->GetBlue(arg2,arg3);
11879
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 {
11884 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11885 }
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11893 PyObject *resultobj;
11894 wxImage *arg1 = (wxImage *) 0 ;
11895 int arg2 ;
11896 int arg3 ;
11897 byte arg4 ;
11898 PyObject * obj0 = 0 ;
11899 PyObject * obj1 = 0 ;
11900 PyObject * obj2 = 0 ;
11901 PyObject * obj3 = 0 ;
11902 char *kwnames[] = {
11903 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11904 };
11905
11906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11908 if (SWIG_arg_fail(1)) SWIG_fail;
11909 {
11910 arg2 = (int)(SWIG_As_int(obj1));
11911 if (SWIG_arg_fail(2)) SWIG_fail;
11912 }
11913 {
11914 arg3 = (int)(SWIG_As_int(obj2));
11915 if (SWIG_arg_fail(3)) SWIG_fail;
11916 }
11917 {
11918 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11919 if (SWIG_arg_fail(4)) SWIG_fail;
11920 }
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 (arg1)->SetAlpha(arg2,arg3,arg4);
11924
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 Py_INCREF(Py_None); resultobj = Py_None;
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 int arg2 ;
11939 int arg3 ;
11940 byte result;
11941 PyObject * obj0 = 0 ;
11942 PyObject * obj1 = 0 ;
11943 PyObject * obj2 = 0 ;
11944 char *kwnames[] = {
11945 (char *) "self",(char *) "x",(char *) "y", NULL
11946 };
11947
11948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11950 if (SWIG_arg_fail(1)) SWIG_fail;
11951 {
11952 arg2 = (int)(SWIG_As_int(obj1));
11953 if (SWIG_arg_fail(2)) SWIG_fail;
11954 }
11955 {
11956 arg3 = (int)(SWIG_As_int(obj2));
11957 if (SWIG_arg_fail(3)) SWIG_fail;
11958 }
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj;
11977 wxImage *arg1 = (wxImage *) 0 ;
11978 bool result;
11979 PyObject * obj0 = 0 ;
11980 char *kwnames[] = {
11981 (char *) "self", NULL
11982 };
11983
11984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11986 if (SWIG_arg_fail(1)) SWIG_fail;
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (bool)(arg1)->HasAlpha();
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxImage *arg1 = (wxImage *) 0 ;
12006 PyObject * obj0 = 0 ;
12007 char *kwnames[] = {
12008 (char *) "self", NULL
12009 };
12010
12011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12013 if (SWIG_arg_fail(1)) SWIG_fail;
12014 {
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 (arg1)->InitAlpha();
12017
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 Py_INCREF(Py_None); resultobj = Py_None;
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12029 PyObject *resultobj;
12030 wxImage *arg1 = (wxImage *) 0 ;
12031 int arg2 ;
12032 int arg3 ;
12033 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12034 bool result;
12035 PyObject * obj0 = 0 ;
12036 PyObject * obj1 = 0 ;
12037 PyObject * obj2 = 0 ;
12038 PyObject * obj3 = 0 ;
12039 char *kwnames[] = {
12040 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12041 };
12042
12043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12045 if (SWIG_arg_fail(1)) SWIG_fail;
12046 {
12047 arg2 = (int)(SWIG_As_int(obj1));
12048 if (SWIG_arg_fail(2)) SWIG_fail;
12049 }
12050 {
12051 arg3 = (int)(SWIG_As_int(obj2));
12052 if (SWIG_arg_fail(3)) SWIG_fail;
12053 }
12054 if (obj3) {
12055 {
12056 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12057 if (SWIG_arg_fail(4)) SWIG_fail;
12058 }
12059 }
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 {
12068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12069 }
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj;
12078 wxImage *arg1 = (wxImage *) 0 ;
12079 byte *arg2 = (byte *) 0 ;
12080 byte *arg3 = (byte *) 0 ;
12081 byte *arg4 = (byte *) 0 ;
12082 byte arg5 = (byte) 0 ;
12083 byte arg6 = (byte) 0 ;
12084 byte arg7 = (byte) 0 ;
12085 bool result;
12086 byte temp2 ;
12087 int res2 = 0 ;
12088 byte temp3 ;
12089 int res3 = 0 ;
12090 byte temp4 ;
12091 int res4 = 0 ;
12092 PyObject * obj0 = 0 ;
12093 PyObject * obj1 = 0 ;
12094 PyObject * obj2 = 0 ;
12095 PyObject * obj3 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12098 };
12099
12100 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12101 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12102 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12105 if (SWIG_arg_fail(1)) SWIG_fail;
12106 if (obj1) {
12107 {
12108 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12109 if (SWIG_arg_fail(5)) SWIG_fail;
12110 }
12111 }
12112 if (obj2) {
12113 {
12114 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12115 if (SWIG_arg_fail(6)) SWIG_fail;
12116 }
12117 }
12118 if (obj3) {
12119 {
12120 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12121 if (SWIG_arg_fail(7)) SWIG_fail;
12122 }
12123 }
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12127
12128 wxPyEndAllowThreads(__tstate);
12129 if (PyErr_Occurred()) SWIG_fail;
12130 }
12131 {
12132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12133 }
12134 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12135 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12136 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12137 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12138 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12139 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12147 PyObject *resultobj;
12148 wxImage *arg1 = (wxImage *) 0 ;
12149 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12150 bool result;
12151 PyObject * obj0 = 0 ;
12152 PyObject * obj1 = 0 ;
12153 char *kwnames[] = {
12154 (char *) "self",(char *) "threshold", NULL
12155 };
12156
12157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12159 if (SWIG_arg_fail(1)) SWIG_fail;
12160 if (obj1) {
12161 {
12162 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12163 if (SWIG_arg_fail(2)) SWIG_fail;
12164 }
12165 }
12166 {
12167 PyThreadState* __tstate = wxPyBeginAllowThreads();
12168 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12169
12170 wxPyEndAllowThreads(__tstate);
12171 if (PyErr_Occurred()) SWIG_fail;
12172 }
12173 {
12174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12175 }
12176 return resultobj;
12177 fail:
12178 return NULL;
12179 }
12180
12181
12182 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12183 PyObject *resultobj;
12184 wxImage *arg1 = (wxImage *) 0 ;
12185 byte arg2 ;
12186 byte arg3 ;
12187 byte arg4 ;
12188 bool result;
12189 PyObject * obj0 = 0 ;
12190 PyObject * obj1 = 0 ;
12191 PyObject * obj2 = 0 ;
12192 PyObject * obj3 = 0 ;
12193 char *kwnames[] = {
12194 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12195 };
12196
12197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12199 if (SWIG_arg_fail(1)) SWIG_fail;
12200 {
12201 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12202 if (SWIG_arg_fail(2)) SWIG_fail;
12203 }
12204 {
12205 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12206 if (SWIG_arg_fail(3)) SWIG_fail;
12207 }
12208 {
12209 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12210 if (SWIG_arg_fail(4)) SWIG_fail;
12211 }
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12215
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 {
12220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12221 }
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxImage *arg1 = (wxImage *) 0 ;
12231 wxImage *arg2 = 0 ;
12232 byte arg3 ;
12233 byte arg4 ;
12234 byte arg5 ;
12235 bool result;
12236 PyObject * obj0 = 0 ;
12237 PyObject * obj1 = 0 ;
12238 PyObject * obj2 = 0 ;
12239 PyObject * obj3 = 0 ;
12240 PyObject * obj4 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12247 if (SWIG_arg_fail(1)) SWIG_fail;
12248 {
12249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12250 if (SWIG_arg_fail(2)) SWIG_fail;
12251 if (arg2 == NULL) {
12252 SWIG_null_ref("wxImage");
12253 }
12254 if (SWIG_arg_fail(2)) SWIG_fail;
12255 }
12256 {
12257 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12258 if (SWIG_arg_fail(3)) SWIG_fail;
12259 }
12260 {
12261 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12262 if (SWIG_arg_fail(4)) SWIG_fail;
12263 }
12264 {
12265 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
12266 if (SWIG_arg_fail(5)) SWIG_fail;
12267 }
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12271
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 {
12276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12277 }
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj;
12286 wxString *arg1 = 0 ;
12287 bool result;
12288 bool temp1 = false ;
12289 PyObject * obj0 = 0 ;
12290 char *kwnames[] = {
12291 (char *) "filename", NULL
12292 };
12293
12294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12295 {
12296 arg1 = wxString_in_helper(obj0);
12297 if (arg1 == NULL) SWIG_fail;
12298 temp1 = true;
12299 }
12300 {
12301 PyThreadState* __tstate = wxPyBeginAllowThreads();
12302 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12303
12304 wxPyEndAllowThreads(__tstate);
12305 if (PyErr_Occurred()) SWIG_fail;
12306 }
12307 {
12308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12309 }
12310 {
12311 if (temp1)
12312 delete arg1;
12313 }
12314 return resultobj;
12315 fail:
12316 {
12317 if (temp1)
12318 delete arg1;
12319 }
12320 return NULL;
12321 }
12322
12323
12324 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj;
12326 wxString *arg1 = 0 ;
12327 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12328 int result;
12329 bool temp1 = false ;
12330 PyObject * obj0 = 0 ;
12331 PyObject * obj1 = 0 ;
12332 char *kwnames[] = {
12333 (char *) "filename",(char *) "type", NULL
12334 };
12335
12336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12337 {
12338 arg1 = wxString_in_helper(obj0);
12339 if (arg1 == NULL) SWIG_fail;
12340 temp1 = true;
12341 }
12342 if (obj1) {
12343 {
12344 arg2 = (long)(SWIG_As_long(obj1));
12345 if (SWIG_arg_fail(2)) SWIG_fail;
12346 }
12347 }
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12351
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 {
12356 resultobj = SWIG_From_int((int)(result));
12357 }
12358 {
12359 if (temp1)
12360 delete arg1;
12361 }
12362 return resultobj;
12363 fail:
12364 {
12365 if (temp1)
12366 delete arg1;
12367 }
12368 return NULL;
12369 }
12370
12371
12372 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12373 PyObject *resultobj;
12374 wxImage *arg1 = (wxImage *) 0 ;
12375 wxString *arg2 = 0 ;
12376 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12377 int arg4 = (int) -1 ;
12378 bool result;
12379 bool temp2 = false ;
12380 PyObject * obj0 = 0 ;
12381 PyObject * obj1 = 0 ;
12382 PyObject * obj2 = 0 ;
12383 PyObject * obj3 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 arg2 = wxString_in_helper(obj1);
12393 if (arg2 == NULL) SWIG_fail;
12394 temp2 = true;
12395 }
12396 if (obj2) {
12397 {
12398 arg3 = (long)(SWIG_As_long(obj2));
12399 if (SWIG_arg_fail(3)) SWIG_fail;
12400 }
12401 }
12402 if (obj3) {
12403 {
12404 arg4 = (int)(SWIG_As_int(obj3));
12405 if (SWIG_arg_fail(4)) SWIG_fail;
12406 }
12407 }
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 {
12416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12417 }
12418 {
12419 if (temp2)
12420 delete arg2;
12421 }
12422 return resultobj;
12423 fail:
12424 {
12425 if (temp2)
12426 delete arg2;
12427 }
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj;
12434 wxImage *arg1 = (wxImage *) 0 ;
12435 wxString *arg2 = 0 ;
12436 wxString *arg3 = 0 ;
12437 int arg4 = (int) -1 ;
12438 bool result;
12439 bool temp2 = false ;
12440 bool temp3 = false ;
12441 PyObject * obj0 = 0 ;
12442 PyObject * obj1 = 0 ;
12443 PyObject * obj2 = 0 ;
12444 PyObject * obj3 = 0 ;
12445 char *kwnames[] = {
12446 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12447 };
12448
12449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12451 if (SWIG_arg_fail(1)) SWIG_fail;
12452 {
12453 arg2 = wxString_in_helper(obj1);
12454 if (arg2 == NULL) SWIG_fail;
12455 temp2 = true;
12456 }
12457 {
12458 arg3 = wxString_in_helper(obj2);
12459 if (arg3 == NULL) SWIG_fail;
12460 temp3 = true;
12461 }
12462 if (obj3) {
12463 {
12464 arg4 = (int)(SWIG_As_int(obj3));
12465 if (SWIG_arg_fail(4)) SWIG_fail;
12466 }
12467 }
12468 {
12469 PyThreadState* __tstate = wxPyBeginAllowThreads();
12470 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12471
12472 wxPyEndAllowThreads(__tstate);
12473 if (PyErr_Occurred()) SWIG_fail;
12474 }
12475 {
12476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12477 }
12478 {
12479 if (temp2)
12480 delete arg2;
12481 }
12482 {
12483 if (temp3)
12484 delete arg3;
12485 }
12486 return resultobj;
12487 fail:
12488 {
12489 if (temp2)
12490 delete arg2;
12491 }
12492 {
12493 if (temp3)
12494 delete arg3;
12495 }
12496 return NULL;
12497 }
12498
12499
12500 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj;
12502 wxImage *arg1 = (wxImage *) 0 ;
12503 wxString *arg2 = 0 ;
12504 int arg3 ;
12505 bool result;
12506 bool temp2 = false ;
12507 PyObject * obj0 = 0 ;
12508 PyObject * obj1 = 0 ;
12509 PyObject * obj2 = 0 ;
12510 char *kwnames[] = {
12511 (char *) "self",(char *) "name",(char *) "type", NULL
12512 };
12513
12514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12516 if (SWIG_arg_fail(1)) SWIG_fail;
12517 {
12518 arg2 = wxString_in_helper(obj1);
12519 if (arg2 == NULL) SWIG_fail;
12520 temp2 = true;
12521 }
12522 {
12523 arg3 = (int)(SWIG_As_int(obj2));
12524 if (SWIG_arg_fail(3)) SWIG_fail;
12525 }
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 {
12534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12535 }
12536 {
12537 if (temp2)
12538 delete arg2;
12539 }
12540 return resultobj;
12541 fail:
12542 {
12543 if (temp2)
12544 delete arg2;
12545 }
12546 return NULL;
12547 }
12548
12549
12550 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12551 PyObject *resultobj;
12552 wxImage *arg1 = (wxImage *) 0 ;
12553 wxString *arg2 = 0 ;
12554 wxString *arg3 = 0 ;
12555 bool result;
12556 bool temp2 = false ;
12557 bool temp3 = false ;
12558 PyObject * obj0 = 0 ;
12559 PyObject * obj1 = 0 ;
12560 PyObject * obj2 = 0 ;
12561 char *kwnames[] = {
12562 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12563 };
12564
12565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(1)) SWIG_fail;
12568 {
12569 arg2 = wxString_in_helper(obj1);
12570 if (arg2 == NULL) SWIG_fail;
12571 temp2 = true;
12572 }
12573 {
12574 arg3 = wxString_in_helper(obj2);
12575 if (arg3 == NULL) SWIG_fail;
12576 temp3 = true;
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12581
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12587 }
12588 {
12589 if (temp2)
12590 delete arg2;
12591 }
12592 {
12593 if (temp3)
12594 delete arg3;
12595 }
12596 return resultobj;
12597 fail:
12598 {
12599 if (temp2)
12600 delete arg2;
12601 }
12602 {
12603 if (temp3)
12604 delete arg3;
12605 }
12606 return NULL;
12607 }
12608
12609
12610 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj;
12612 wxInputStream *arg1 = 0 ;
12613 bool result;
12614 wxPyInputStream *temp1 ;
12615 bool created1 ;
12616 PyObject * obj0 = 0 ;
12617 char *kwnames[] = {
12618 (char *) "stream", NULL
12619 };
12620
12621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12622 {
12623 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12624 arg1 = temp1->m_wxis;
12625 created1 = false;
12626 } else {
12627 PyErr_Clear(); // clear the failure of the wxPyConvert above
12628 arg1 = wxPyCBInputStream_create(obj0, false);
12629 if (arg1 == NULL) {
12630 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12631 SWIG_fail;
12632 }
12633 created1 = true;
12634 }
12635 }
12636 {
12637 PyThreadState* __tstate = wxPyBeginAllowThreads();
12638 result = (bool)wxImage::CanRead(*arg1);
12639
12640 wxPyEndAllowThreads(__tstate);
12641 if (PyErr_Occurred()) SWIG_fail;
12642 }
12643 {
12644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12645 }
12646 {
12647 if (created1) delete arg1;
12648 }
12649 return resultobj;
12650 fail:
12651 {
12652 if (created1) delete arg1;
12653 }
12654 return NULL;
12655 }
12656
12657
12658 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12659 PyObject *resultobj;
12660 wxImage *arg1 = (wxImage *) 0 ;
12661 wxInputStream *arg2 = 0 ;
12662 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12663 int arg4 = (int) -1 ;
12664 bool result;
12665 wxPyInputStream *temp2 ;
12666 bool created2 ;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 PyObject * obj2 = 0 ;
12670 PyObject * obj3 = 0 ;
12671 char *kwnames[] = {
12672 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12673 };
12674
12675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
12679 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12680 arg2 = temp2->m_wxis;
12681 created2 = false;
12682 } else {
12683 PyErr_Clear(); // clear the failure of the wxPyConvert above
12684 arg2 = wxPyCBInputStream_create(obj1, false);
12685 if (arg2 == NULL) {
12686 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12687 SWIG_fail;
12688 }
12689 created2 = true;
12690 }
12691 }
12692 if (obj2) {
12693 {
12694 arg3 = (long)(SWIG_As_long(obj2));
12695 if (SWIG_arg_fail(3)) SWIG_fail;
12696 }
12697 }
12698 if (obj3) {
12699 {
12700 arg4 = (int)(SWIG_As_int(obj3));
12701 if (SWIG_arg_fail(4)) SWIG_fail;
12702 }
12703 }
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12707
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 {
12712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12713 }
12714 {
12715 if (created2) delete arg2;
12716 }
12717 return resultobj;
12718 fail:
12719 {
12720 if (created2) delete arg2;
12721 }
12722 return NULL;
12723 }
12724
12725
12726 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj;
12728 wxImage *arg1 = (wxImage *) 0 ;
12729 wxInputStream *arg2 = 0 ;
12730 wxString *arg3 = 0 ;
12731 int arg4 = (int) -1 ;
12732 bool result;
12733 wxPyInputStream *temp2 ;
12734 bool created2 ;
12735 bool temp3 = false ;
12736 PyObject * obj0 = 0 ;
12737 PyObject * obj1 = 0 ;
12738 PyObject * obj2 = 0 ;
12739 PyObject * obj3 = 0 ;
12740 char *kwnames[] = {
12741 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12742 };
12743
12744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(1)) SWIG_fail;
12747 {
12748 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12749 arg2 = temp2->m_wxis;
12750 created2 = false;
12751 } else {
12752 PyErr_Clear(); // clear the failure of the wxPyConvert above
12753 arg2 = wxPyCBInputStream_create(obj1, false);
12754 if (arg2 == NULL) {
12755 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12756 SWIG_fail;
12757 }
12758 created2 = true;
12759 }
12760 }
12761 {
12762 arg3 = wxString_in_helper(obj2);
12763 if (arg3 == NULL) SWIG_fail;
12764 temp3 = true;
12765 }
12766 if (obj3) {
12767 {
12768 arg4 = (int)(SWIG_As_int(obj3));
12769 if (SWIG_arg_fail(4)) SWIG_fail;
12770 }
12771 }
12772 {
12773 PyThreadState* __tstate = wxPyBeginAllowThreads();
12774 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12775
12776 wxPyEndAllowThreads(__tstate);
12777 if (PyErr_Occurred()) SWIG_fail;
12778 }
12779 {
12780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12781 }
12782 {
12783 if (created2) delete arg2;
12784 }
12785 {
12786 if (temp3)
12787 delete arg3;
12788 }
12789 return resultobj;
12790 fail:
12791 {
12792 if (created2) delete arg2;
12793 }
12794 {
12795 if (temp3)
12796 delete arg3;
12797 }
12798 return NULL;
12799 }
12800
12801
12802 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12803 PyObject *resultobj;
12804 wxImage *arg1 = (wxImage *) 0 ;
12805 bool result;
12806 PyObject * obj0 = 0 ;
12807 char *kwnames[] = {
12808 (char *) "self", NULL
12809 };
12810
12811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12813 if (SWIG_arg_fail(1)) SWIG_fail;
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (bool)(arg1)->Ok();
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 {
12822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12823 }
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj;
12832 wxImage *arg1 = (wxImage *) 0 ;
12833 int result;
12834 PyObject * obj0 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "self", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(1)) SWIG_fail;
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (int)(arg1)->GetWidth();
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 resultobj = SWIG_From_int((int)(result));
12851 }
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj;
12860 wxImage *arg1 = (wxImage *) 0 ;
12861 int result;
12862 PyObject * obj0 = 0 ;
12863 char *kwnames[] = {
12864 (char *) "self", NULL
12865 };
12866
12867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12869 if (SWIG_arg_fail(1)) SWIG_fail;
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 result = (int)(arg1)->GetHeight();
12873
12874 wxPyEndAllowThreads(__tstate);
12875 if (PyErr_Occurred()) SWIG_fail;
12876 }
12877 {
12878 resultobj = SWIG_From_int((int)(result));
12879 }
12880 return resultobj;
12881 fail:
12882 return NULL;
12883 }
12884
12885
12886 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj;
12888 wxImage *arg1 = (wxImage *) 0 ;
12889 wxSize result;
12890 PyObject * obj0 = 0 ;
12891 char *kwnames[] = {
12892 (char *) "self", NULL
12893 };
12894
12895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12897 if (SWIG_arg_fail(1)) SWIG_fail;
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 result = wxImage_GetSize(arg1);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 {
12906 wxSize * resultptr;
12907 resultptr = new wxSize((wxSize &)(result));
12908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12909 }
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj;
12918 wxImage *arg1 = (wxImage *) 0 ;
12919 wxRect *arg2 = 0 ;
12920 SwigValueWrapper<wxImage > result;
12921 wxRect temp2 ;
12922 PyObject * obj0 = 0 ;
12923 PyObject * obj1 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self",(char *) "rect", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 arg2 = &temp2;
12933 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12934 }
12935 {
12936 PyThreadState* __tstate = wxPyBeginAllowThreads();
12937 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12938
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 {
12943 wxImage * resultptr;
12944 resultptr = new wxImage((wxImage &)(result));
12945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12946 }
12947 return resultobj;
12948 fail:
12949 return NULL;
12950 }
12951
12952
12953 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12954 PyObject *resultobj;
12955 wxImage *arg1 = (wxImage *) 0 ;
12956 wxSize *arg2 = 0 ;
12957 wxPoint *arg3 = 0 ;
12958 int arg4 = (int) -1 ;
12959 int arg5 = (int) -1 ;
12960 int arg6 = (int) -1 ;
12961 SwigValueWrapper<wxImage > result;
12962 wxSize temp2 ;
12963 wxPoint temp3 ;
12964 PyObject * obj0 = 0 ;
12965 PyObject * obj1 = 0 ;
12966 PyObject * obj2 = 0 ;
12967 PyObject * obj3 = 0 ;
12968 PyObject * obj4 = 0 ;
12969 PyObject * obj5 = 0 ;
12970 char *kwnames[] = {
12971 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12972 };
12973
12974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12976 if (SWIG_arg_fail(1)) SWIG_fail;
12977 {
12978 arg2 = &temp2;
12979 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12980 }
12981 {
12982 arg3 = &temp3;
12983 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12984 }
12985 if (obj3) {
12986 {
12987 arg4 = (int)(SWIG_As_int(obj3));
12988 if (SWIG_arg_fail(4)) SWIG_fail;
12989 }
12990 }
12991 if (obj4) {
12992 {
12993 arg5 = (int)(SWIG_As_int(obj4));
12994 if (SWIG_arg_fail(5)) SWIG_fail;
12995 }
12996 }
12997 if (obj5) {
12998 {
12999 arg6 = (int)(SWIG_As_int(obj5));
13000 if (SWIG_arg_fail(6)) SWIG_fail;
13001 }
13002 }
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13006
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 {
13011 wxImage * resultptr;
13012 resultptr = new wxImage((wxImage &)(result));
13013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13014 }
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13022 PyObject *resultobj;
13023 wxImage *arg1 = (wxImage *) 0 ;
13024 SwigValueWrapper<wxImage > result;
13025 PyObject * obj0 = 0 ;
13026 char *kwnames[] = {
13027 (char *) "self", NULL
13028 };
13029
13030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13032 if (SWIG_arg_fail(1)) SWIG_fail;
13033 {
13034 PyThreadState* __tstate = wxPyBeginAllowThreads();
13035 result = (arg1)->Copy();
13036
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 {
13041 wxImage * resultptr;
13042 resultptr = new wxImage((wxImage &)(result));
13043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13044 }
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj;
13053 wxImage *arg1 = (wxImage *) 0 ;
13054 wxImage *arg2 = 0 ;
13055 int arg3 ;
13056 int arg4 ;
13057 PyObject * obj0 = 0 ;
13058 PyObject * obj1 = 0 ;
13059 PyObject * obj2 = 0 ;
13060 PyObject * obj3 = 0 ;
13061 char *kwnames[] = {
13062 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13063 };
13064
13065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13067 if (SWIG_arg_fail(1)) SWIG_fail;
13068 {
13069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13070 if (SWIG_arg_fail(2)) SWIG_fail;
13071 if (arg2 == NULL) {
13072 SWIG_null_ref("wxImage");
13073 }
13074 if (SWIG_arg_fail(2)) SWIG_fail;
13075 }
13076 {
13077 arg3 = (int)(SWIG_As_int(obj2));
13078 if (SWIG_arg_fail(3)) SWIG_fail;
13079 }
13080 {
13081 arg4 = (int)(SWIG_As_int(obj3));
13082 if (SWIG_arg_fail(4)) SWIG_fail;
13083 }
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13087
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 Py_INCREF(Py_None); resultobj = Py_None;
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13099 PyObject *resultobj;
13100 wxImage *arg1 = (wxImage *) 0 ;
13101 PyObject *result;
13102 PyObject * obj0 = 0 ;
13103 char *kwnames[] = {
13104 (char *) "self", NULL
13105 };
13106
13107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(1)) SWIG_fail;
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 result = (PyObject *)wxImage_GetData(arg1);
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 resultobj = result;
13118 return resultobj;
13119 fail:
13120 return NULL;
13121 }
13122
13123
13124 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13125 PyObject *resultobj;
13126 wxImage *arg1 = (wxImage *) 0 ;
13127 buffer arg2 ;
13128 int arg3 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13131 char *kwnames[] = {
13132 (char *) "self",(char *) "data", NULL
13133 };
13134
13135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(1)) SWIG_fail;
13138 {
13139 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 wxImage_SetData(arg1,arg2,arg3);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 Py_INCREF(Py_None); resultobj = Py_None;
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxImage *arg1 = (wxImage *) 0 ;
13158 PyObject *result;
13159 PyObject * obj0 = 0 ;
13160 char *kwnames[] = {
13161 (char *) "self", NULL
13162 };
13163
13164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13166 if (SWIG_arg_fail(1)) SWIG_fail;
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13170
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = result;
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj;
13183 wxImage *arg1 = (wxImage *) 0 ;
13184 buffer arg2 ;
13185 int arg3 ;
13186 PyObject * obj0 = 0 ;
13187 PyObject * obj1 = 0 ;
13188 char *kwnames[] = {
13189 (char *) "self",(char *) "data", NULL
13190 };
13191
13192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13194 if (SWIG_arg_fail(1)) SWIG_fail;
13195 {
13196 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13197 }
13198 {
13199 PyThreadState* __tstate = wxPyBeginAllowThreads();
13200 wxImage_SetDataBuffer(arg1,arg2,arg3);
13201
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 Py_INCREF(Py_None); resultobj = Py_None;
13206 return resultobj;
13207 fail:
13208 return NULL;
13209 }
13210
13211
13212 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13213 PyObject *resultobj;
13214 wxImage *arg1 = (wxImage *) 0 ;
13215 PyObject *result;
13216 PyObject * obj0 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "self", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13223 if (SWIG_arg_fail(1)) SWIG_fail;
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (PyObject *)wxImage_GetAlphaData(arg1);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 resultobj = result;
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj;
13240 wxImage *arg1 = (wxImage *) 0 ;
13241 buffer arg2 ;
13242 int arg3 ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245 char *kwnames[] = {
13246 (char *) "self",(char *) "alpha", NULL
13247 };
13248
13249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13251 if (SWIG_arg_fail(1)) SWIG_fail;
13252 {
13253 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13254 }
13255 {
13256 PyThreadState* __tstate = wxPyBeginAllowThreads();
13257 wxImage_SetAlphaData(arg1,arg2,arg3);
13258
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 Py_INCREF(Py_None); resultobj = Py_None;
13263 return resultobj;
13264 fail:
13265 return NULL;
13266 }
13267
13268
13269 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13270 PyObject *resultobj;
13271 wxImage *arg1 = (wxImage *) 0 ;
13272 PyObject *result;
13273 PyObject * obj0 = 0 ;
13274 char *kwnames[] = {
13275 (char *) "self", NULL
13276 };
13277
13278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13280 if (SWIG_arg_fail(1)) SWIG_fail;
13281 {
13282 PyThreadState* __tstate = wxPyBeginAllowThreads();
13283 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13284
13285 wxPyEndAllowThreads(__tstate);
13286 if (PyErr_Occurred()) SWIG_fail;
13287 }
13288 resultobj = result;
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxImage *arg1 = (wxImage *) 0 ;
13298 buffer arg2 ;
13299 int arg3 ;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "alpha", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 {
13310 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13315
13316 wxPyEndAllowThreads(__tstate);
13317 if (PyErr_Occurred()) SWIG_fail;
13318 }
13319 Py_INCREF(Py_None); resultobj = Py_None;
13320 return resultobj;
13321 fail:
13322 return NULL;
13323 }
13324
13325
13326 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13327 PyObject *resultobj;
13328 wxImage *arg1 = (wxImage *) 0 ;
13329 byte arg2 ;
13330 byte arg3 ;
13331 byte arg4 ;
13332 PyObject * obj0 = 0 ;
13333 PyObject * obj1 = 0 ;
13334 PyObject * obj2 = 0 ;
13335 PyObject * obj3 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13342 if (SWIG_arg_fail(1)) SWIG_fail;
13343 {
13344 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13345 if (SWIG_arg_fail(2)) SWIG_fail;
13346 }
13347 {
13348 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13349 if (SWIG_arg_fail(3)) SWIG_fail;
13350 }
13351 {
13352 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13353 if (SWIG_arg_fail(4)) SWIG_fail;
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 (arg1)->SetMaskColour(arg2,arg3,arg4);
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 Py_INCREF(Py_None); resultobj = Py_None;
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj;
13371 wxImage *arg1 = (wxImage *) 0 ;
13372 byte *arg2 = (byte *) 0 ;
13373 byte *arg3 = (byte *) 0 ;
13374 byte *arg4 = (byte *) 0 ;
13375 byte temp2 ;
13376 int res2 = 0 ;
13377 byte temp3 ;
13378 int res3 = 0 ;
13379 byte temp4 ;
13380 int res4 = 0 ;
13381 PyObject * obj0 = 0 ;
13382 char *kwnames[] = {
13383 (char *) "self", NULL
13384 };
13385
13386 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13387 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13388 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13391 if (SWIG_arg_fail(1)) SWIG_fail;
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 Py_INCREF(Py_None); resultobj = Py_None;
13400 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13401 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13402 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13403 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13404 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13405 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj;
13414 wxImage *arg1 = (wxImage *) 0 ;
13415 byte result;
13416 PyObject * obj0 = 0 ;
13417 char *kwnames[] = {
13418 (char *) "self", NULL
13419 };
13420
13421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13423 if (SWIG_arg_fail(1)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = (byte)(arg1)->GetMaskRed();
13427
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13433 }
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj;
13442 wxImage *arg1 = (wxImage *) 0 ;
13443 byte result;
13444 PyObject * obj0 = 0 ;
13445 char *kwnames[] = {
13446 (char *) "self", NULL
13447 };
13448
13449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13451 if (SWIG_arg_fail(1)) SWIG_fail;
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 result = (byte)(arg1)->GetMaskGreen();
13455
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13461 }
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13469 PyObject *resultobj;
13470 wxImage *arg1 = (wxImage *) 0 ;
13471 byte result;
13472 PyObject * obj0 = 0 ;
13473 char *kwnames[] = {
13474 (char *) "self", NULL
13475 };
13476
13477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13479 if (SWIG_arg_fail(1)) SWIG_fail;
13480 {
13481 PyThreadState* __tstate = wxPyBeginAllowThreads();
13482 result = (byte)(arg1)->GetMaskBlue();
13483
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 {
13488 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13489 }
13490 return resultobj;
13491 fail:
13492 return NULL;
13493 }
13494
13495
13496 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13497 PyObject *resultobj;
13498 wxImage *arg1 = (wxImage *) 0 ;
13499 bool arg2 = (bool) true ;
13500 PyObject * obj0 = 0 ;
13501 PyObject * obj1 = 0 ;
13502 char *kwnames[] = {
13503 (char *) "self",(char *) "mask", NULL
13504 };
13505
13506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13508 if (SWIG_arg_fail(1)) SWIG_fail;
13509 if (obj1) {
13510 {
13511 arg2 = (bool)(SWIG_As_bool(obj1));
13512 if (SWIG_arg_fail(2)) SWIG_fail;
13513 }
13514 }
13515 {
13516 PyThreadState* __tstate = wxPyBeginAllowThreads();
13517 (arg1)->SetMask(arg2);
13518
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 Py_INCREF(Py_None); resultobj = Py_None;
13523 return resultobj;
13524 fail:
13525 return NULL;
13526 }
13527
13528
13529 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13530 PyObject *resultobj;
13531 wxImage *arg1 = (wxImage *) 0 ;
13532 bool result;
13533 PyObject * obj0 = 0 ;
13534 char *kwnames[] = {
13535 (char *) "self", NULL
13536 };
13537
13538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13540 if (SWIG_arg_fail(1)) SWIG_fail;
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = (bool)(arg1)->HasMask();
13544
13545 wxPyEndAllowThreads(__tstate);
13546 if (PyErr_Occurred()) SWIG_fail;
13547 }
13548 {
13549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13550 }
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj;
13559 wxImage *arg1 = (wxImage *) 0 ;
13560 double arg2 ;
13561 wxPoint *arg3 = 0 ;
13562 bool arg4 = (bool) true ;
13563 wxPoint *arg5 = (wxPoint *) NULL ;
13564 SwigValueWrapper<wxImage > result;
13565 wxPoint temp3 ;
13566 PyObject * obj0 = 0 ;
13567 PyObject * obj1 = 0 ;
13568 PyObject * obj2 = 0 ;
13569 PyObject * obj3 = 0 ;
13570 PyObject * obj4 = 0 ;
13571 char *kwnames[] = {
13572 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13577 if (SWIG_arg_fail(1)) SWIG_fail;
13578 {
13579 arg2 = (double)(SWIG_As_double(obj1));
13580 if (SWIG_arg_fail(2)) SWIG_fail;
13581 }
13582 {
13583 arg3 = &temp3;
13584 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13585 }
13586 if (obj3) {
13587 {
13588 arg4 = (bool)(SWIG_As_bool(obj3));
13589 if (SWIG_arg_fail(4)) SWIG_fail;
13590 }
13591 }
13592 if (obj4) {
13593 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13594 if (SWIG_arg_fail(5)) SWIG_fail;
13595 }
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 {
13604 wxImage * resultptr;
13605 resultptr = new wxImage((wxImage &)(result));
13606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13607 }
13608 return resultobj;
13609 fail:
13610 return NULL;
13611 }
13612
13613
13614 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13615 PyObject *resultobj;
13616 wxImage *arg1 = (wxImage *) 0 ;
13617 bool arg2 = (bool) true ;
13618 SwigValueWrapper<wxImage > result;
13619 PyObject * obj0 = 0 ;
13620 PyObject * obj1 = 0 ;
13621 char *kwnames[] = {
13622 (char *) "self",(char *) "clockwise", NULL
13623 };
13624
13625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13627 if (SWIG_arg_fail(1)) SWIG_fail;
13628 if (obj1) {
13629 {
13630 arg2 = (bool)(SWIG_As_bool(obj1));
13631 if (SWIG_arg_fail(2)) SWIG_fail;
13632 }
13633 }
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (arg1)->Rotate90(arg2);
13637
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 {
13642 wxImage * resultptr;
13643 resultptr = new wxImage((wxImage &)(result));
13644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13645 }
13646 return resultobj;
13647 fail:
13648 return NULL;
13649 }
13650
13651
13652 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13653 PyObject *resultobj;
13654 wxImage *arg1 = (wxImage *) 0 ;
13655 bool arg2 = (bool) true ;
13656 SwigValueWrapper<wxImage > result;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 char *kwnames[] = {
13660 (char *) "self",(char *) "horizontally", NULL
13661 };
13662
13663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13665 if (SWIG_arg_fail(1)) SWIG_fail;
13666 if (obj1) {
13667 {
13668 arg2 = (bool)(SWIG_As_bool(obj1));
13669 if (SWIG_arg_fail(2)) SWIG_fail;
13670 }
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 result = (arg1)->Mirror(arg2);
13675
13676 wxPyEndAllowThreads(__tstate);
13677 if (PyErr_Occurred()) SWIG_fail;
13678 }
13679 {
13680 wxImage * resultptr;
13681 resultptr = new wxImage((wxImage &)(result));
13682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13683 }
13684 return resultobj;
13685 fail:
13686 return NULL;
13687 }
13688
13689
13690 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13691 PyObject *resultobj;
13692 wxImage *arg1 = (wxImage *) 0 ;
13693 byte arg2 ;
13694 byte arg3 ;
13695 byte arg4 ;
13696 byte arg5 ;
13697 byte arg6 ;
13698 byte arg7 ;
13699 PyObject * obj0 = 0 ;
13700 PyObject * obj1 = 0 ;
13701 PyObject * obj2 = 0 ;
13702 PyObject * obj3 = 0 ;
13703 PyObject * obj4 = 0 ;
13704 PyObject * obj5 = 0 ;
13705 PyObject * obj6 = 0 ;
13706 char *kwnames[] = {
13707 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13708 };
13709
13710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(1)) SWIG_fail;
13713 {
13714 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13715 if (SWIG_arg_fail(2)) SWIG_fail;
13716 }
13717 {
13718 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13719 if (SWIG_arg_fail(3)) SWIG_fail;
13720 }
13721 {
13722 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13723 if (SWIG_arg_fail(4)) SWIG_fail;
13724 }
13725 {
13726 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13727 if (SWIG_arg_fail(5)) SWIG_fail;
13728 }
13729 {
13730 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13731 if (SWIG_arg_fail(6)) SWIG_fail;
13732 }
13733 {
13734 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13735 if (SWIG_arg_fail(7)) SWIG_fail;
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13740
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 Py_INCREF(Py_None); resultobj = Py_None;
13745 return resultobj;
13746 fail:
13747 return NULL;
13748 }
13749
13750
13751 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13752 PyObject *resultobj;
13753 wxImage *arg1 = (wxImage *) 0 ;
13754 byte arg2 ;
13755 byte arg3 ;
13756 byte arg4 ;
13757 SwigValueWrapper<wxImage > result;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 PyObject * obj3 = 0 ;
13762 char *kwnames[] = {
13763 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13764 };
13765
13766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13768 if (SWIG_arg_fail(1)) SWIG_fail;
13769 {
13770 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13771 if (SWIG_arg_fail(2)) SWIG_fail;
13772 }
13773 {
13774 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13775 if (SWIG_arg_fail(3)) SWIG_fail;
13776 }
13777 {
13778 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13779 if (SWIG_arg_fail(4)) SWIG_fail;
13780 }
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13784
13785 wxPyEndAllowThreads(__tstate);
13786 if (PyErr_Occurred()) SWIG_fail;
13787 }
13788 {
13789 wxImage * resultptr;
13790 resultptr = new wxImage((wxImage &)(result));
13791 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13792 }
13793 return resultobj;
13794 fail:
13795 return NULL;
13796 }
13797
13798
13799 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13800 PyObject *resultobj;
13801 wxImage *arg1 = (wxImage *) 0 ;
13802 wxString *arg2 = 0 ;
13803 wxString *arg3 = 0 ;
13804 bool temp2 = false ;
13805 bool temp3 = false ;
13806 PyObject * obj0 = 0 ;
13807 PyObject * obj1 = 0 ;
13808 PyObject * obj2 = 0 ;
13809 char *kwnames[] = {
13810 (char *) "self",(char *) "name",(char *) "value", NULL
13811 };
13812
13813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13815 if (SWIG_arg_fail(1)) SWIG_fail;
13816 {
13817 arg2 = wxString_in_helper(obj1);
13818 if (arg2 == NULL) SWIG_fail;
13819 temp2 = true;
13820 }
13821 {
13822 arg3 = wxString_in_helper(obj2);
13823 if (arg3 == NULL) SWIG_fail;
13824 temp3 = true;
13825 }
13826 {
13827 PyThreadState* __tstate = wxPyBeginAllowThreads();
13828 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13829
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 Py_INCREF(Py_None); resultobj = Py_None;
13834 {
13835 if (temp2)
13836 delete arg2;
13837 }
13838 {
13839 if (temp3)
13840 delete arg3;
13841 }
13842 return resultobj;
13843 fail:
13844 {
13845 if (temp2)
13846 delete arg2;
13847 }
13848 {
13849 if (temp3)
13850 delete arg3;
13851 }
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj;
13858 wxImage *arg1 = (wxImage *) 0 ;
13859 wxString *arg2 = 0 ;
13860 int arg3 ;
13861 bool temp2 = false ;
13862 PyObject * obj0 = 0 ;
13863 PyObject * obj1 = 0 ;
13864 PyObject * obj2 = 0 ;
13865 char *kwnames[] = {
13866 (char *) "self",(char *) "name",(char *) "value", NULL
13867 };
13868
13869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13871 if (SWIG_arg_fail(1)) SWIG_fail;
13872 {
13873 arg2 = wxString_in_helper(obj1);
13874 if (arg2 == NULL) SWIG_fail;
13875 temp2 = true;
13876 }
13877 {
13878 arg3 = (int)(SWIG_As_int(obj2));
13879 if (SWIG_arg_fail(3)) SWIG_fail;
13880 }
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 (arg1)->SetOption((wxString const &)*arg2,arg3);
13884
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 Py_INCREF(Py_None); resultobj = Py_None;
13889 {
13890 if (temp2)
13891 delete arg2;
13892 }
13893 return resultobj;
13894 fail:
13895 {
13896 if (temp2)
13897 delete arg2;
13898 }
13899 return NULL;
13900 }
13901
13902
13903 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13904 PyObject *resultobj;
13905 wxImage *arg1 = (wxImage *) 0 ;
13906 wxString *arg2 = 0 ;
13907 wxString result;
13908 bool temp2 = false ;
13909 PyObject * obj0 = 0 ;
13910 PyObject * obj1 = 0 ;
13911 char *kwnames[] = {
13912 (char *) "self",(char *) "name", NULL
13913 };
13914
13915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13917 if (SWIG_arg_fail(1)) SWIG_fail;
13918 {
13919 arg2 = wxString_in_helper(obj1);
13920 if (arg2 == NULL) SWIG_fail;
13921 temp2 = true;
13922 }
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 {
13931 #if wxUSE_UNICODE
13932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13933 #else
13934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13935 #endif
13936 }
13937 {
13938 if (temp2)
13939 delete arg2;
13940 }
13941 return resultobj;
13942 fail:
13943 {
13944 if (temp2)
13945 delete arg2;
13946 }
13947 return NULL;
13948 }
13949
13950
13951 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj;
13953 wxImage *arg1 = (wxImage *) 0 ;
13954 wxString *arg2 = 0 ;
13955 int result;
13956 bool temp2 = false ;
13957 PyObject * obj0 = 0 ;
13958 PyObject * obj1 = 0 ;
13959 char *kwnames[] = {
13960 (char *) "self",(char *) "name", NULL
13961 };
13962
13963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13965 if (SWIG_arg_fail(1)) SWIG_fail;
13966 {
13967 arg2 = wxString_in_helper(obj1);
13968 if (arg2 == NULL) SWIG_fail;
13969 temp2 = true;
13970 }
13971 {
13972 PyThreadState* __tstate = wxPyBeginAllowThreads();
13973 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13974
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 {
13979 resultobj = SWIG_From_int((int)(result));
13980 }
13981 {
13982 if (temp2)
13983 delete arg2;
13984 }
13985 return resultobj;
13986 fail:
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return NULL;
13992 }
13993
13994
13995 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13996 PyObject *resultobj;
13997 wxImage *arg1 = (wxImage *) 0 ;
13998 wxString *arg2 = 0 ;
13999 bool result;
14000 bool temp2 = false ;
14001 PyObject * obj0 = 0 ;
14002 PyObject * obj1 = 0 ;
14003 char *kwnames[] = {
14004 (char *) "self",(char *) "name", NULL
14005 };
14006
14007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14009 if (SWIG_arg_fail(1)) SWIG_fail;
14010 {
14011 arg2 = wxString_in_helper(obj1);
14012 if (arg2 == NULL) SWIG_fail;
14013 temp2 = true;
14014 }
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14018
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 {
14023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14024 }
14025 {
14026 if (temp2)
14027 delete arg2;
14028 }
14029 return resultobj;
14030 fail:
14031 {
14032 if (temp2)
14033 delete arg2;
14034 }
14035 return NULL;
14036 }
14037
14038
14039 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14040 PyObject *resultobj;
14041 wxImage *arg1 = (wxImage *) 0 ;
14042 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14043 unsigned long result;
14044 PyObject * obj0 = 0 ;
14045 PyObject * obj1 = 0 ;
14046 char *kwnames[] = {
14047 (char *) "self",(char *) "stopafter", NULL
14048 };
14049
14050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14052 if (SWIG_arg_fail(1)) SWIG_fail;
14053 if (obj1) {
14054 {
14055 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
14056 if (SWIG_arg_fail(2)) SWIG_fail;
14057 }
14058 }
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 result = (unsigned long)(arg1)->CountColours(arg2);
14062
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 {
14067 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14068 }
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14076 PyObject *resultobj;
14077 wxImage *arg1 = (wxImage *) 0 ;
14078 wxImageHistogram *arg2 = 0 ;
14079 unsigned long result;
14080 PyObject * obj0 = 0 ;
14081 PyObject * obj1 = 0 ;
14082 char *kwnames[] = {
14083 (char *) "self",(char *) "h", NULL
14084 };
14085
14086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14088 if (SWIG_arg_fail(1)) SWIG_fail;
14089 {
14090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14091 if (SWIG_arg_fail(2)) SWIG_fail;
14092 if (arg2 == NULL) {
14093 SWIG_null_ref("wxImageHistogram");
14094 }
14095 if (SWIG_arg_fail(2)) SWIG_fail;
14096 }
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14100
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 {
14105 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14106 }
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14116 PyObject * obj0 = 0 ;
14117 char *kwnames[] = {
14118 (char *) "handler", NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14123 if (SWIG_arg_fail(1)) SWIG_fail;
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 wxImage::AddHandler(arg1);
14127
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 Py_INCREF(Py_None); resultobj = Py_None;
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14141 PyObject * obj0 = 0 ;
14142 char *kwnames[] = {
14143 (char *) "handler", NULL
14144 };
14145
14146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14148 if (SWIG_arg_fail(1)) SWIG_fail;
14149 {
14150 PyThreadState* __tstate = wxPyBeginAllowThreads();
14151 wxImage::InsertHandler(arg1);
14152
14153 wxPyEndAllowThreads(__tstate);
14154 if (PyErr_Occurred()) SWIG_fail;
14155 }
14156 Py_INCREF(Py_None); resultobj = Py_None;
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14164 PyObject *resultobj;
14165 wxString *arg1 = 0 ;
14166 bool result;
14167 bool temp1 = false ;
14168 PyObject * obj0 = 0 ;
14169 char *kwnames[] = {
14170 (char *) "name", NULL
14171 };
14172
14173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14174 {
14175 arg1 = wxString_in_helper(obj0);
14176 if (arg1 == NULL) SWIG_fail;
14177 temp1 = true;
14178 }
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 {
14187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14188 }
14189 {
14190 if (temp1)
14191 delete arg1;
14192 }
14193 return resultobj;
14194 fail:
14195 {
14196 if (temp1)
14197 delete arg1;
14198 }
14199 return NULL;
14200 }
14201
14202
14203 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14204 PyObject *resultobj;
14205 wxString result;
14206 char *kwnames[] = {
14207 NULL
14208 };
14209
14210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 result = wxImage::GetImageExtWildcard();
14214
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 #if wxUSE_UNICODE
14220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14221 #else
14222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14223 #endif
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14232 PyObject *resultobj;
14233 wxImage *arg1 = (wxImage *) 0 ;
14234 int arg2 = (int) -1 ;
14235 wxBitmap result;
14236 PyObject * obj0 = 0 ;
14237 PyObject * obj1 = 0 ;
14238 char *kwnames[] = {
14239 (char *) "self",(char *) "depth", NULL
14240 };
14241
14242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14244 if (SWIG_arg_fail(1)) SWIG_fail;
14245 if (obj1) {
14246 {
14247 arg2 = (int)(SWIG_As_int(obj1));
14248 if (SWIG_arg_fail(2)) SWIG_fail;
14249 }
14250 }
14251 {
14252 if (!wxPyCheckForApp()) SWIG_fail;
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 result = wxImage_ConvertToBitmap(arg1,arg2);
14255
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 {
14260 wxBitmap * resultptr;
14261 resultptr = new wxBitmap((wxBitmap &)(result));
14262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14263 }
14264 return resultobj;
14265 fail:
14266 return NULL;
14267 }
14268
14269
14270 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14271 PyObject *resultobj;
14272 wxImage *arg1 = (wxImage *) 0 ;
14273 byte arg2 ;
14274 byte arg3 ;
14275 byte arg4 ;
14276 wxBitmap result;
14277 PyObject * obj0 = 0 ;
14278 PyObject * obj1 = 0 ;
14279 PyObject * obj2 = 0 ;
14280 PyObject * obj3 = 0 ;
14281 char *kwnames[] = {
14282 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14283 };
14284
14285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14287 if (SWIG_arg_fail(1)) SWIG_fail;
14288 {
14289 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
14290 if (SWIG_arg_fail(2)) SWIG_fail;
14291 }
14292 {
14293 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
14294 if (SWIG_arg_fail(3)) SWIG_fail;
14295 }
14296 {
14297 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
14298 if (SWIG_arg_fail(4)) SWIG_fail;
14299 }
14300 {
14301 if (!wxPyCheckForApp()) SWIG_fail;
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14304
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 {
14309 wxBitmap * resultptr;
14310 resultptr = new wxBitmap((wxBitmap &)(result));
14311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj;
14321 wxImage *arg1 = (wxImage *) 0 ;
14322 double arg2 ;
14323 PyObject * obj0 = 0 ;
14324 PyObject * obj1 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self",(char *) "angle", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 {
14333 arg2 = (double)(SWIG_As_double(obj1));
14334 if (SWIG_arg_fail(2)) SWIG_fail;
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 (arg1)->RotateHue(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_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj;
14352 wxImage_RGBValue arg1 ;
14353 wxImage_HSVValue result;
14354 PyObject * obj0 = 0 ;
14355 char *kwnames[] = {
14356 (char *) "rgb", NULL
14357 };
14358
14359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14360 {
14361 wxImage_RGBValue * argp;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 if (argp == NULL) {
14365 SWIG_null_ref("wxImage_RGBValue");
14366 }
14367 if (SWIG_arg_fail(1)) SWIG_fail;
14368 arg1 = *argp;
14369 }
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = wxImage::RGBtoHSV(arg1);
14373
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 {
14378 wxImage_HSVValue * resultptr;
14379 resultptr = new wxImage_HSVValue((wxImage_HSVValue &)(result));
14380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14381 }
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj;
14390 wxImage_HSVValue arg1 ;
14391 wxImage_RGBValue result;
14392 PyObject * obj0 = 0 ;
14393 char *kwnames[] = {
14394 (char *) "hsv", NULL
14395 };
14396
14397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14398 {
14399 wxImage_HSVValue * argp;
14400 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14401 if (SWIG_arg_fail(1)) SWIG_fail;
14402 if (argp == NULL) {
14403 SWIG_null_ref("wxImage_HSVValue");
14404 }
14405 if (SWIG_arg_fail(1)) SWIG_fail;
14406 arg1 = *argp;
14407 }
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = wxImage::HSVtoRGB(arg1);
14411
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 wxImage_RGBValue * resultptr;
14417 resultptr = new wxImage_RGBValue((wxImage_RGBValue &)(result));
14418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14419 }
14420 return resultobj;
14421 fail:
14422 return NULL;
14423 }
14424
14425
14426 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14427 PyObject *obj;
14428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14429 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14430 Py_INCREF(obj);
14431 return Py_BuildValue((char *)"");
14432 }
14433 static int _wrap_NullImage_set(PyObject *) {
14434 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14435 return 1;
14436 }
14437
14438
14439 static PyObject *_wrap_NullImage_get(void) {
14440 PyObject *pyobj;
14441
14442 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14443 return pyobj;
14444 }
14445
14446
14447 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14448 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14449 return 1;
14450 }
14451
14452
14453 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14454 PyObject *pyobj;
14455
14456 {
14457 #if wxUSE_UNICODE
14458 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14459 #else
14460 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14461 #endif
14462 }
14463 return pyobj;
14464 }
14465
14466
14467 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14468 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14469 return 1;
14470 }
14471
14472
14473 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14474 PyObject *pyobj;
14475
14476 {
14477 #if wxUSE_UNICODE
14478 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14479 #else
14480 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14481 #endif
14482 }
14483 return pyobj;
14484 }
14485
14486
14487 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14488 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14489 return 1;
14490 }
14491
14492
14493 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14494 PyObject *pyobj;
14495
14496 {
14497 #if wxUSE_UNICODE
14498 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14499 #else
14500 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14501 #endif
14502 }
14503 return pyobj;
14504 }
14505
14506
14507 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14508 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14509 return 1;
14510 }
14511
14512
14513 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14514 PyObject *pyobj;
14515
14516 {
14517 #if wxUSE_UNICODE
14518 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14519 #else
14520 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14521 #endif
14522 }
14523 return pyobj;
14524 }
14525
14526
14527 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14528 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14529 return 1;
14530 }
14531
14532
14533 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14534 PyObject *pyobj;
14535
14536 {
14537 #if wxUSE_UNICODE
14538 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14539 #else
14540 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14541 #endif
14542 }
14543 return pyobj;
14544 }
14545
14546
14547 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14548 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14549 return 1;
14550 }
14551
14552
14553 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14554 PyObject *pyobj;
14555
14556 {
14557 #if wxUSE_UNICODE
14558 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14559 #else
14560 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14561 #endif
14562 }
14563 return pyobj;
14564 }
14565
14566
14567 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14568 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14569 return 1;
14570 }
14571
14572
14573 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14574 PyObject *pyobj;
14575
14576 {
14577 #if wxUSE_UNICODE
14578 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14579 #else
14580 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14581 #endif
14582 }
14583 return pyobj;
14584 }
14585
14586
14587 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14588 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14589 return 1;
14590 }
14591
14592
14593 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14594 PyObject *pyobj;
14595
14596 {
14597 #if wxUSE_UNICODE
14598 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14599 #else
14600 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14601 #endif
14602 }
14603 return pyobj;
14604 }
14605
14606
14607 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14608 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14609 return 1;
14610 }
14611
14612
14613 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14614 PyObject *pyobj;
14615
14616 {
14617 #if wxUSE_UNICODE
14618 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14619 #else
14620 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14621 #endif
14622 }
14623 return pyobj;
14624 }
14625
14626
14627 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14628 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14629 return 1;
14630 }
14631
14632
14633 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14634 PyObject *pyobj;
14635
14636 {
14637 #if wxUSE_UNICODE
14638 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14639 #else
14640 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14641 #endif
14642 }
14643 return pyobj;
14644 }
14645
14646
14647 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14648 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14649 return 1;
14650 }
14651
14652
14653 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14654 PyObject *pyobj;
14655
14656 {
14657 #if wxUSE_UNICODE
14658 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14659 #else
14660 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14661 #endif
14662 }
14663 return pyobj;
14664 }
14665
14666
14667 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14668 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14669 return 1;
14670 }
14671
14672
14673 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14674 PyObject *pyobj;
14675
14676 {
14677 #if wxUSE_UNICODE
14678 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14679 #else
14680 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14681 #endif
14682 }
14683 return pyobj;
14684 }
14685
14686
14687 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14688 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14689 return 1;
14690 }
14691
14692
14693 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14694 PyObject *pyobj;
14695
14696 {
14697 #if wxUSE_UNICODE
14698 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14699 #else
14700 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14701 #endif
14702 }
14703 return pyobj;
14704 }
14705
14706
14707 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14708 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14709 return 1;
14710 }
14711
14712
14713 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14714 PyObject *pyobj;
14715
14716 {
14717 #if wxUSE_UNICODE
14718 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14719 #else
14720 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14721 #endif
14722 }
14723 return pyobj;
14724 }
14725
14726
14727 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14728 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14729 return 1;
14730 }
14731
14732
14733 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14734 PyObject *pyobj;
14735
14736 {
14737 #if wxUSE_UNICODE
14738 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14739 #else
14740 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14741 #endif
14742 }
14743 return pyobj;
14744 }
14745
14746
14747 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj;
14749 wxBMPHandler *result;
14750 char *kwnames[] = {
14751 NULL
14752 };
14753
14754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14755 {
14756 PyThreadState* __tstate = wxPyBeginAllowThreads();
14757 result = (wxBMPHandler *)new wxBMPHandler();
14758
14759 wxPyEndAllowThreads(__tstate);
14760 if (PyErr_Occurred()) SWIG_fail;
14761 }
14762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14763 return resultobj;
14764 fail:
14765 return NULL;
14766 }
14767
14768
14769 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14770 PyObject *obj;
14771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14772 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14773 Py_INCREF(obj);
14774 return Py_BuildValue((char *)"");
14775 }
14776 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxICOHandler *result;
14779 char *kwnames[] = {
14780 NULL
14781 };
14782
14783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (wxICOHandler *)new wxICOHandler();
14787
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14799 PyObject *obj;
14800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14801 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14802 Py_INCREF(obj);
14803 return Py_BuildValue((char *)"");
14804 }
14805 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj;
14807 wxCURHandler *result;
14808 char *kwnames[] = {
14809 NULL
14810 };
14811
14812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = (wxCURHandler *)new wxCURHandler();
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14821 return resultobj;
14822 fail:
14823 return NULL;
14824 }
14825
14826
14827 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14828 PyObject *obj;
14829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14830 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14831 Py_INCREF(obj);
14832 return Py_BuildValue((char *)"");
14833 }
14834 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj;
14836 wxANIHandler *result;
14837 char *kwnames[] = {
14838 NULL
14839 };
14840
14841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14842 {
14843 PyThreadState* __tstate = wxPyBeginAllowThreads();
14844 result = (wxANIHandler *)new wxANIHandler();
14845
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14857 PyObject *obj;
14858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14859 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14860 Py_INCREF(obj);
14861 return Py_BuildValue((char *)"");
14862 }
14863 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxPNGHandler *result;
14866 char *kwnames[] = {
14867 NULL
14868 };
14869
14870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (wxPNGHandler *)new wxPNGHandler();
14874
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14879 return resultobj;
14880 fail:
14881 return NULL;
14882 }
14883
14884
14885 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14886 PyObject *obj;
14887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14888 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14889 Py_INCREF(obj);
14890 return Py_BuildValue((char *)"");
14891 }
14892 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14893 PyObject *resultobj;
14894 wxGIFHandler *result;
14895 char *kwnames[] = {
14896 NULL
14897 };
14898
14899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = (wxGIFHandler *)new wxGIFHandler();
14903
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14915 PyObject *obj;
14916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14917 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14918 Py_INCREF(obj);
14919 return Py_BuildValue((char *)"");
14920 }
14921 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj;
14923 wxPCXHandler *result;
14924 char *kwnames[] = {
14925 NULL
14926 };
14927
14928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 result = (wxPCXHandler *)new wxPCXHandler();
14932
14933 wxPyEndAllowThreads(__tstate);
14934 if (PyErr_Occurred()) SWIG_fail;
14935 }
14936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14937 return resultobj;
14938 fail:
14939 return NULL;
14940 }
14941
14942
14943 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14944 PyObject *obj;
14945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14946 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14947 Py_INCREF(obj);
14948 return Py_BuildValue((char *)"");
14949 }
14950 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14951 PyObject *resultobj;
14952 wxJPEGHandler *result;
14953 char *kwnames[] = {
14954 NULL
14955 };
14956
14957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14958 {
14959 PyThreadState* __tstate = wxPyBeginAllowThreads();
14960 result = (wxJPEGHandler *)new wxJPEGHandler();
14961
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14966 return resultobj;
14967 fail:
14968 return NULL;
14969 }
14970
14971
14972 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14973 PyObject *obj;
14974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14975 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14976 Py_INCREF(obj);
14977 return Py_BuildValue((char *)"");
14978 }
14979 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14980 PyObject *resultobj;
14981 wxPNMHandler *result;
14982 char *kwnames[] = {
14983 NULL
14984 };
14985
14986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (wxPNMHandler *)new wxPNMHandler();
14990
14991 wxPyEndAllowThreads(__tstate);
14992 if (PyErr_Occurred()) SWIG_fail;
14993 }
14994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14995 return resultobj;
14996 fail:
14997 return NULL;
14998 }
14999
15000
15001 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15002 PyObject *obj;
15003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15004 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15005 Py_INCREF(obj);
15006 return Py_BuildValue((char *)"");
15007 }
15008 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15009 PyObject *resultobj;
15010 wxXPMHandler *result;
15011 char *kwnames[] = {
15012 NULL
15013 };
15014
15015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15016 {
15017 PyThreadState* __tstate = wxPyBeginAllowThreads();
15018 result = (wxXPMHandler *)new wxXPMHandler();
15019
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15031 PyObject *obj;
15032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15033 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15034 Py_INCREF(obj);
15035 return Py_BuildValue((char *)"");
15036 }
15037 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15038 PyObject *resultobj;
15039 wxTIFFHandler *result;
15040 char *kwnames[] = {
15041 NULL
15042 };
15043
15044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (wxTIFFHandler *)new wxTIFFHandler();
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15053 return resultobj;
15054 fail:
15055 return NULL;
15056 }
15057
15058
15059 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15060 PyObject *obj;
15061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15062 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15063 Py_INCREF(obj);
15064 return Py_BuildValue((char *)"");
15065 }
15066 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxImage *arg1 = 0 ;
15069 wxImage *arg2 = 0 ;
15070 int arg3 = (int) 236 ;
15071 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15072 bool result;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 PyObject * obj2 = 0 ;
15076 PyObject * obj3 = 0 ;
15077 char *kwnames[] = {
15078 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15082 {
15083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15084 if (SWIG_arg_fail(1)) SWIG_fail;
15085 if (arg1 == NULL) {
15086 SWIG_null_ref("wxImage");
15087 }
15088 if (SWIG_arg_fail(1)) SWIG_fail;
15089 }
15090 {
15091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(2)) SWIG_fail;
15093 if (arg2 == NULL) {
15094 SWIG_null_ref("wxImage");
15095 }
15096 if (SWIG_arg_fail(2)) SWIG_fail;
15097 }
15098 if (obj2) {
15099 {
15100 arg3 = (int)(SWIG_As_int(obj2));
15101 if (SWIG_arg_fail(3)) SWIG_fail;
15102 }
15103 }
15104 if (obj3) {
15105 {
15106 arg4 = (int)(SWIG_As_int(obj3));
15107 if (SWIG_arg_fail(4)) SWIG_fail;
15108 }
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 {
15118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15119 }
15120 return resultobj;
15121 fail:
15122 return NULL;
15123 }
15124
15125
15126 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15127 PyObject *obj;
15128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15129 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15130 Py_INCREF(obj);
15131 return Py_BuildValue((char *)"");
15132 }
15133 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15134 PyObject *resultobj;
15135 wxEvtHandler *result;
15136 char *kwnames[] = {
15137 NULL
15138 };
15139
15140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (wxEvtHandler *)new wxEvtHandler();
15144
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj;
15157 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15158 wxEvtHandler *result;
15159 PyObject * obj0 = 0 ;
15160 char *kwnames[] = {
15161 (char *) "self", NULL
15162 };
15163
15164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15166 if (SWIG_arg_fail(1)) SWIG_fail;
15167 {
15168 PyThreadState* __tstate = wxPyBeginAllowThreads();
15169 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15170
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 {
15175 resultobj = wxPyMake_wxObject(result, 0);
15176 }
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj;
15185 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15186 wxEvtHandler *result;
15187 PyObject * obj0 = 0 ;
15188 char *kwnames[] = {
15189 (char *) "self", NULL
15190 };
15191
15192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15194 if (SWIG_arg_fail(1)) SWIG_fail;
15195 {
15196 PyThreadState* __tstate = wxPyBeginAllowThreads();
15197 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15198
15199 wxPyEndAllowThreads(__tstate);
15200 if (PyErr_Occurred()) SWIG_fail;
15201 }
15202 {
15203 resultobj = wxPyMake_wxObject(result, 0);
15204 }
15205 return resultobj;
15206 fail:
15207 return NULL;
15208 }
15209
15210
15211 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15212 PyObject *resultobj;
15213 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15214 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15215 PyObject * obj0 = 0 ;
15216 PyObject * obj1 = 0 ;
15217 char *kwnames[] = {
15218 (char *) "self",(char *) "handler", NULL
15219 };
15220
15221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15223 if (SWIG_arg_fail(1)) SWIG_fail;
15224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15225 if (SWIG_arg_fail(2)) SWIG_fail;
15226 {
15227 PyThreadState* __tstate = wxPyBeginAllowThreads();
15228 (arg1)->SetNextHandler(arg2);
15229
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 Py_INCREF(Py_None); resultobj = Py_None;
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15243 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15244 PyObject * obj0 = 0 ;
15245 PyObject * obj1 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self",(char *) "handler", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(2)) SWIG_fail;
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 (arg1)->SetPreviousHandler(arg2);
15258
15259 wxPyEndAllowThreads(__tstate);
15260 if (PyErr_Occurred()) SWIG_fail;
15261 }
15262 Py_INCREF(Py_None); resultobj = Py_None;
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15270 PyObject *resultobj;
15271 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15272 bool result;
15273 PyObject * obj0 = 0 ;
15274 char *kwnames[] = {
15275 (char *) "self", NULL
15276 };
15277
15278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15280 if (SWIG_arg_fail(1)) SWIG_fail;
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (bool)(arg1)->GetEvtHandlerEnabled();
15284
15285 wxPyEndAllowThreads(__tstate);
15286 if (PyErr_Occurred()) SWIG_fail;
15287 }
15288 {
15289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15290 }
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj;
15299 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15300 bool arg2 ;
15301 PyObject * obj0 = 0 ;
15302 PyObject * obj1 = 0 ;
15303 char *kwnames[] = {
15304 (char *) "self",(char *) "enabled", NULL
15305 };
15306
15307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15309 if (SWIG_arg_fail(1)) SWIG_fail;
15310 {
15311 arg2 = (bool)(SWIG_As_bool(obj1));
15312 if (SWIG_arg_fail(2)) SWIG_fail;
15313 }
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 (arg1)->SetEvtHandlerEnabled(arg2);
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 Py_INCREF(Py_None); resultobj = Py_None;
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15329 PyObject *resultobj;
15330 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15331 wxEvent *arg2 = 0 ;
15332 bool result;
15333 PyObject * obj0 = 0 ;
15334 PyObject * obj1 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self",(char *) "event", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15344 if (SWIG_arg_fail(2)) SWIG_fail;
15345 if (arg2 == NULL) {
15346 SWIG_null_ref("wxEvent");
15347 }
15348 if (SWIG_arg_fail(2)) SWIG_fail;
15349 }
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (bool)(arg1)->ProcessEvent(*arg2);
15353
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 {
15358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15359 }
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj;
15368 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15369 wxEvent *arg2 = 0 ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "self",(char *) "event", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 {
15380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15381 if (SWIG_arg_fail(2)) SWIG_fail;
15382 if (arg2 == NULL) {
15383 SWIG_null_ref("wxEvent");
15384 }
15385 if (SWIG_arg_fail(2)) SWIG_fail;
15386 }
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 (arg1)->AddPendingEvent(*arg2);
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 Py_INCREF(Py_None); resultobj = Py_None;
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15402 PyObject *resultobj;
15403 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15404 PyObject * obj0 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 {
15413 PyThreadState* __tstate = wxPyBeginAllowThreads();
15414 (arg1)->ProcessPendingEvents();
15415
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 Py_INCREF(Py_None); resultobj = Py_None;
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15427 PyObject *resultobj;
15428 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15429 int arg2 ;
15430 int arg3 ;
15431 int arg4 ;
15432 PyObject *arg5 = (PyObject *) 0 ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 PyObject * obj2 = 0 ;
15436 PyObject * obj3 = 0 ;
15437 PyObject * obj4 = 0 ;
15438 char *kwnames[] = {
15439 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15440 };
15441
15442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15444 if (SWIG_arg_fail(1)) SWIG_fail;
15445 {
15446 arg2 = (int)(SWIG_As_int(obj1));
15447 if (SWIG_arg_fail(2)) SWIG_fail;
15448 }
15449 {
15450 arg3 = (int)(SWIG_As_int(obj2));
15451 if (SWIG_arg_fail(3)) SWIG_fail;
15452 }
15453 {
15454 arg4 = (int)(SWIG_As_int(obj3));
15455 if (SWIG_arg_fail(4)) SWIG_fail;
15456 }
15457 arg5 = obj4;
15458 {
15459 PyThreadState* __tstate = wxPyBeginAllowThreads();
15460 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15461
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 Py_INCREF(Py_None); resultobj = Py_None;
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj;
15474 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15475 int arg2 ;
15476 int arg3 = (int) -1 ;
15477 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15478 bool result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 PyObject * obj2 = 0 ;
15482 PyObject * obj3 = 0 ;
15483 char *kwnames[] = {
15484 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15485 };
15486
15487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15489 if (SWIG_arg_fail(1)) SWIG_fail;
15490 {
15491 arg2 = (int)(SWIG_As_int(obj1));
15492 if (SWIG_arg_fail(2)) SWIG_fail;
15493 }
15494 if (obj2) {
15495 {
15496 arg3 = (int)(SWIG_As_int(obj2));
15497 if (SWIG_arg_fail(3)) SWIG_fail;
15498 }
15499 }
15500 if (obj3) {
15501 {
15502 arg4 = (wxEventType)(SWIG_As_int(obj3));
15503 if (SWIG_arg_fail(4)) SWIG_fail;
15504 }
15505 }
15506 {
15507 PyThreadState* __tstate = wxPyBeginAllowThreads();
15508 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15509
15510 wxPyEndAllowThreads(__tstate);
15511 if (PyErr_Occurred()) SWIG_fail;
15512 }
15513 {
15514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15515 }
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15523 PyObject *resultobj;
15524 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15525 PyObject *arg2 = (PyObject *) 0 ;
15526 bool arg3 = (bool) true ;
15527 PyObject * obj0 = 0 ;
15528 PyObject * obj1 = 0 ;
15529 PyObject * obj2 = 0 ;
15530 char *kwnames[] = {
15531 (char *) "self",(char *) "_self",(char *) "incref", NULL
15532 };
15533
15534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15536 if (SWIG_arg_fail(1)) SWIG_fail;
15537 arg2 = obj1;
15538 if (obj2) {
15539 {
15540 arg3 = (bool)(SWIG_As_bool(obj2));
15541 if (SWIG_arg_fail(3)) SWIG_fail;
15542 }
15543 }
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15547
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 Py_INCREF(Py_None); resultobj = Py_None;
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15559 PyObject *obj;
15560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15561 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15562 Py_INCREF(obj);
15563 return Py_BuildValue((char *)"");
15564 }
15565 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj;
15567 wxEventType result;
15568 char *kwnames[] = {
15569 NULL
15570 };
15571
15572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15573 {
15574 PyThreadState* __tstate = wxPyBeginAllowThreads();
15575 result = (wxEventType)wxNewEventType();
15576
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 {
15581 resultobj = SWIG_From_int((int)(result));
15582 }
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15590 PyObject *resultobj;
15591 wxEvent *arg1 = (wxEvent *) 0 ;
15592 PyObject * obj0 = 0 ;
15593 char *kwnames[] = {
15594 (char *) "self", NULL
15595 };
15596
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 delete arg1;
15603
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 Py_INCREF(Py_None); resultobj = Py_None;
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15615 PyObject *resultobj;
15616 wxEvent *arg1 = (wxEvent *) 0 ;
15617 wxEventType arg2 ;
15618 PyObject * obj0 = 0 ;
15619 PyObject * obj1 = 0 ;
15620 char *kwnames[] = {
15621 (char *) "self",(char *) "typ", NULL
15622 };
15623
15624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15626 if (SWIG_arg_fail(1)) SWIG_fail;
15627 {
15628 arg2 = (wxEventType)(SWIG_As_int(obj1));
15629 if (SWIG_arg_fail(2)) SWIG_fail;
15630 }
15631 {
15632 PyThreadState* __tstate = wxPyBeginAllowThreads();
15633 (arg1)->SetEventType(arg2);
15634
15635 wxPyEndAllowThreads(__tstate);
15636 if (PyErr_Occurred()) SWIG_fail;
15637 }
15638 Py_INCREF(Py_None); resultobj = Py_None;
15639 return resultobj;
15640 fail:
15641 return NULL;
15642 }
15643
15644
15645 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj;
15647 wxEvent *arg1 = (wxEvent *) 0 ;
15648 wxEventType result;
15649 PyObject * obj0 = 0 ;
15650 char *kwnames[] = {
15651 (char *) "self", NULL
15652 };
15653
15654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15656 if (SWIG_arg_fail(1)) SWIG_fail;
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15660
15661 wxPyEndAllowThreads(__tstate);
15662 if (PyErr_Occurred()) SWIG_fail;
15663 }
15664 {
15665 resultobj = SWIG_From_int((int)(result));
15666 }
15667 return resultobj;
15668 fail:
15669 return NULL;
15670 }
15671
15672
15673 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15674 PyObject *resultobj;
15675 wxEvent *arg1 = (wxEvent *) 0 ;
15676 wxObject *result;
15677 PyObject * obj0 = 0 ;
15678 char *kwnames[] = {
15679 (char *) "self", NULL
15680 };
15681
15682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15684 if (SWIG_arg_fail(1)) SWIG_fail;
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15688
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 {
15693 resultobj = wxPyMake_wxObject(result, 0);
15694 }
15695 return resultobj;
15696 fail:
15697 return NULL;
15698 }
15699
15700
15701 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15702 PyObject *resultobj;
15703 wxEvent *arg1 = (wxEvent *) 0 ;
15704 wxObject *arg2 = (wxObject *) 0 ;
15705 PyObject * obj0 = 0 ;
15706 PyObject * obj1 = 0 ;
15707 char *kwnames[] = {
15708 (char *) "self",(char *) "obj", NULL
15709 };
15710
15711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15713 if (SWIG_arg_fail(1)) SWIG_fail;
15714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15715 if (SWIG_arg_fail(2)) SWIG_fail;
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 (arg1)->SetEventObject(arg2);
15719
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 Py_INCREF(Py_None); resultobj = Py_None;
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15731 PyObject *resultobj;
15732 wxEvent *arg1 = (wxEvent *) 0 ;
15733 long result;
15734 PyObject * obj0 = 0 ;
15735 char *kwnames[] = {
15736 (char *) "self", NULL
15737 };
15738
15739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15741 if (SWIG_arg_fail(1)) SWIG_fail;
15742 {
15743 PyThreadState* __tstate = wxPyBeginAllowThreads();
15744 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15745
15746 wxPyEndAllowThreads(__tstate);
15747 if (PyErr_Occurred()) SWIG_fail;
15748 }
15749 {
15750 resultobj = SWIG_From_long((long)(result));
15751 }
15752 return resultobj;
15753 fail:
15754 return NULL;
15755 }
15756
15757
15758 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15759 PyObject *resultobj;
15760 wxEvent *arg1 = (wxEvent *) 0 ;
15761 long arg2 = (long) 0 ;
15762 PyObject * obj0 = 0 ;
15763 PyObject * obj1 = 0 ;
15764 char *kwnames[] = {
15765 (char *) "self",(char *) "ts", NULL
15766 };
15767
15768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15770 if (SWIG_arg_fail(1)) SWIG_fail;
15771 if (obj1) {
15772 {
15773 arg2 = (long)(SWIG_As_long(obj1));
15774 if (SWIG_arg_fail(2)) SWIG_fail;
15775 }
15776 }
15777 {
15778 PyThreadState* __tstate = wxPyBeginAllowThreads();
15779 (arg1)->SetTimestamp(arg2);
15780
15781 wxPyEndAllowThreads(__tstate);
15782 if (PyErr_Occurred()) SWIG_fail;
15783 }
15784 Py_INCREF(Py_None); resultobj = Py_None;
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15792 PyObject *resultobj;
15793 wxEvent *arg1 = (wxEvent *) 0 ;
15794 int result;
15795 PyObject * obj0 = 0 ;
15796 char *kwnames[] = {
15797 (char *) "self", NULL
15798 };
15799
15800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15802 if (SWIG_arg_fail(1)) SWIG_fail;
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 result = (int)((wxEvent const *)arg1)->GetId();
15806
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 {
15811 resultobj = SWIG_From_int((int)(result));
15812 }
15813 return resultobj;
15814 fail:
15815 return NULL;
15816 }
15817
15818
15819 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15820 PyObject *resultobj;
15821 wxEvent *arg1 = (wxEvent *) 0 ;
15822 int arg2 ;
15823 PyObject * obj0 = 0 ;
15824 PyObject * obj1 = 0 ;
15825 char *kwnames[] = {
15826 (char *) "self",(char *) "Id", NULL
15827 };
15828
15829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15831 if (SWIG_arg_fail(1)) SWIG_fail;
15832 {
15833 arg2 = (int)(SWIG_As_int(obj1));
15834 if (SWIG_arg_fail(2)) SWIG_fail;
15835 }
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 (arg1)->SetId(arg2);
15839
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 Py_INCREF(Py_None); resultobj = Py_None;
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15851 PyObject *resultobj;
15852 wxEvent *arg1 = (wxEvent *) 0 ;
15853 bool result;
15854 PyObject * obj0 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15865
15866 wxPyEndAllowThreads(__tstate);
15867 if (PyErr_Occurred()) SWIG_fail;
15868 }
15869 {
15870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15871 }
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj;
15880 wxEvent *arg1 = (wxEvent *) 0 ;
15881 bool arg2 = (bool) true ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 char *kwnames[] = {
15885 (char *) "self",(char *) "skip", NULL
15886 };
15887
15888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15890 if (SWIG_arg_fail(1)) SWIG_fail;
15891 if (obj1) {
15892 {
15893 arg2 = (bool)(SWIG_As_bool(obj1));
15894 if (SWIG_arg_fail(2)) SWIG_fail;
15895 }
15896 }
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 (arg1)->Skip(arg2);
15900
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 Py_INCREF(Py_None); resultobj = Py_None;
15905 return resultobj;
15906 fail:
15907 return NULL;
15908 }
15909
15910
15911 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15912 PyObject *resultobj;
15913 wxEvent *arg1 = (wxEvent *) 0 ;
15914 bool result;
15915 PyObject * obj0 = 0 ;
15916 char *kwnames[] = {
15917 (char *) "self", NULL
15918 };
15919
15920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15922 if (SWIG_arg_fail(1)) SWIG_fail;
15923 {
15924 PyThreadState* __tstate = wxPyBeginAllowThreads();
15925 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15926
15927 wxPyEndAllowThreads(__tstate);
15928 if (PyErr_Occurred()) SWIG_fail;
15929 }
15930 {
15931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15932 }
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj;
15941 wxEvent *arg1 = (wxEvent *) 0 ;
15942 bool result;
15943 PyObject * obj0 = 0 ;
15944 char *kwnames[] = {
15945 (char *) "self", NULL
15946 };
15947
15948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15950 if (SWIG_arg_fail(1)) SWIG_fail;
15951 {
15952 PyThreadState* __tstate = wxPyBeginAllowThreads();
15953 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15954
15955 wxPyEndAllowThreads(__tstate);
15956 if (PyErr_Occurred()) SWIG_fail;
15957 }
15958 {
15959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15960 }
15961 return resultobj;
15962 fail:
15963 return NULL;
15964 }
15965
15966
15967 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15968 PyObject *resultobj;
15969 wxEvent *arg1 = (wxEvent *) 0 ;
15970 int result;
15971 PyObject * obj0 = 0 ;
15972 char *kwnames[] = {
15973 (char *) "self", NULL
15974 };
15975
15976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15978 if (SWIG_arg_fail(1)) SWIG_fail;
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = (int)(arg1)->StopPropagation();
15982
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 {
15987 resultobj = SWIG_From_int((int)(result));
15988 }
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj;
15997 wxEvent *arg1 = (wxEvent *) 0 ;
15998 int arg2 ;
15999 PyObject * obj0 = 0 ;
16000 PyObject * obj1 = 0 ;
16001 char *kwnames[] = {
16002 (char *) "self",(char *) "propagationLevel", NULL
16003 };
16004
16005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16007 if (SWIG_arg_fail(1)) SWIG_fail;
16008 {
16009 arg2 = (int)(SWIG_As_int(obj1));
16010 if (SWIG_arg_fail(2)) SWIG_fail;
16011 }
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 (arg1)->ResumePropagation(arg2);
16015
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 Py_INCREF(Py_None); resultobj = Py_None;
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16027 PyObject *resultobj;
16028 wxEvent *arg1 = (wxEvent *) 0 ;
16029 wxEvent *result;
16030 PyObject * obj0 = 0 ;
16031 char *kwnames[] = {
16032 (char *) "self", NULL
16033 };
16034
16035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16037 if (SWIG_arg_fail(1)) SWIG_fail;
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 result = (wxEvent *)(arg1)->Clone();
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16053 PyObject *obj;
16054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16055 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16056 Py_INCREF(obj);
16057 return Py_BuildValue((char *)"");
16058 }
16059 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxEvent *arg1 = 0 ;
16062 wxPropagationDisabler *result;
16063 PyObject * obj0 = 0 ;
16064 char *kwnames[] = {
16065 (char *) "event", NULL
16066 };
16067
16068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16069 {
16070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16071 if (SWIG_arg_fail(1)) SWIG_fail;
16072 if (arg1 == NULL) {
16073 SWIG_null_ref("wxEvent");
16074 }
16075 if (SWIG_arg_fail(1)) SWIG_fail;
16076 }
16077 {
16078 PyThreadState* __tstate = wxPyBeginAllowThreads();
16079 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16080
16081 wxPyEndAllowThreads(__tstate);
16082 if (PyErr_Occurred()) SWIG_fail;
16083 }
16084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16085 return resultobj;
16086 fail:
16087 return NULL;
16088 }
16089
16090
16091 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16092 PyObject *resultobj;
16093 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16094 PyObject * obj0 = 0 ;
16095 char *kwnames[] = {
16096 (char *) "self", NULL
16097 };
16098
16099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16101 if (SWIG_arg_fail(1)) SWIG_fail;
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 delete arg1;
16105
16106 wxPyEndAllowThreads(__tstate);
16107 if (PyErr_Occurred()) SWIG_fail;
16108 }
16109 Py_INCREF(Py_None); resultobj = Py_None;
16110 return resultobj;
16111 fail:
16112 return NULL;
16113 }
16114
16115
16116 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16117 PyObject *obj;
16118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16119 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16120 Py_INCREF(obj);
16121 return Py_BuildValue((char *)"");
16122 }
16123 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj;
16125 wxEvent *arg1 = 0 ;
16126 wxPropagateOnce *result;
16127 PyObject * obj0 = 0 ;
16128 char *kwnames[] = {
16129 (char *) "event", NULL
16130 };
16131
16132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16133 {
16134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16135 if (SWIG_arg_fail(1)) SWIG_fail;
16136 if (arg1 == NULL) {
16137 SWIG_null_ref("wxEvent");
16138 }
16139 if (SWIG_arg_fail(1)) SWIG_fail;
16140 }
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16144
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16149 return resultobj;
16150 fail:
16151 return NULL;
16152 }
16153
16154
16155 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16156 PyObject *resultobj;
16157 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16158 PyObject * obj0 = 0 ;
16159 char *kwnames[] = {
16160 (char *) "self", NULL
16161 };
16162
16163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16165 if (SWIG_arg_fail(1)) SWIG_fail;
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 delete arg1;
16169
16170 wxPyEndAllowThreads(__tstate);
16171 if (PyErr_Occurred()) SWIG_fail;
16172 }
16173 Py_INCREF(Py_None); resultobj = Py_None;
16174 return resultobj;
16175 fail:
16176 return NULL;
16177 }
16178
16179
16180 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16181 PyObject *obj;
16182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16183 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16184 Py_INCREF(obj);
16185 return Py_BuildValue((char *)"");
16186 }
16187 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16190 int arg2 = (int) 0 ;
16191 wxCommandEvent *result;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "commandType",(char *) "winid", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16199 if (obj0) {
16200 {
16201 arg1 = (wxEventType)(SWIG_As_int(obj0));
16202 if (SWIG_arg_fail(1)) SWIG_fail;
16203 }
16204 }
16205 if (obj1) {
16206 {
16207 arg2 = (int)(SWIG_As_int(obj1));
16208 if (SWIG_arg_fail(2)) SWIG_fail;
16209 }
16210 }
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16228 int result;
16229 PyObject * obj0 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = SWIG_From_int((int)(result));
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16256 wxString *arg2 = 0 ;
16257 bool temp2 = false ;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self",(char *) "s", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 arg2 = wxString_in_helper(obj1);
16269 if (arg2 == NULL) SWIG_fail;
16270 temp2 = true;
16271 }
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 (arg1)->SetString((wxString const &)*arg2);
16275
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 Py_INCREF(Py_None); resultobj = Py_None;
16280 {
16281 if (temp2)
16282 delete arg2;
16283 }
16284 return resultobj;
16285 fail:
16286 {
16287 if (temp2)
16288 delete arg2;
16289 }
16290 return NULL;
16291 }
16292
16293
16294 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16295 PyObject *resultobj;
16296 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16297 wxString result;
16298 PyObject * obj0 = 0 ;
16299 char *kwnames[] = {
16300 (char *) "self", NULL
16301 };
16302
16303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16305 if (SWIG_arg_fail(1)) SWIG_fail;
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 result = ((wxCommandEvent const *)arg1)->GetString();
16309
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 {
16314 #if wxUSE_UNICODE
16315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16316 #else
16317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16318 #endif
16319 }
16320 return resultobj;
16321 fail:
16322 return NULL;
16323 }
16324
16325
16326 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16327 PyObject *resultobj;
16328 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16329 bool result;
16330 PyObject * obj0 = 0 ;
16331 char *kwnames[] = {
16332 (char *) "self", NULL
16333 };
16334
16335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16337 if (SWIG_arg_fail(1)) SWIG_fail;
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16341
16342 wxPyEndAllowThreads(__tstate);
16343 if (PyErr_Occurred()) SWIG_fail;
16344 }
16345 {
16346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16347 }
16348 return resultobj;
16349 fail:
16350 return NULL;
16351 }
16352
16353
16354 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16355 PyObject *resultobj;
16356 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16357 bool result;
16358 PyObject * obj0 = 0 ;
16359 char *kwnames[] = {
16360 (char *) "self", NULL
16361 };
16362
16363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16365 if (SWIG_arg_fail(1)) SWIG_fail;
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16369
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 {
16374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16375 }
16376 return resultobj;
16377 fail:
16378 return NULL;
16379 }
16380
16381
16382 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16383 PyObject *resultobj;
16384 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16385 long arg2 ;
16386 PyObject * obj0 = 0 ;
16387 PyObject * obj1 = 0 ;
16388 char *kwnames[] = {
16389 (char *) "self",(char *) "extraLong", NULL
16390 };
16391
16392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16394 if (SWIG_arg_fail(1)) SWIG_fail;
16395 {
16396 arg2 = (long)(SWIG_As_long(obj1));
16397 if (SWIG_arg_fail(2)) SWIG_fail;
16398 }
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 (arg1)->SetExtraLong(arg2);
16402
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 Py_INCREF(Py_None); resultobj = Py_None;
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16414 PyObject *resultobj;
16415 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16416 long result;
16417 PyObject * obj0 = 0 ;
16418 char *kwnames[] = {
16419 (char *) "self", NULL
16420 };
16421
16422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16424 if (SWIG_arg_fail(1)) SWIG_fail;
16425 {
16426 PyThreadState* __tstate = wxPyBeginAllowThreads();
16427 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16428
16429 wxPyEndAllowThreads(__tstate);
16430 if (PyErr_Occurred()) SWIG_fail;
16431 }
16432 {
16433 resultobj = SWIG_From_long((long)(result));
16434 }
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj;
16443 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16444 int arg2 ;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 char *kwnames[] = {
16448 (char *) "self",(char *) "i", NULL
16449 };
16450
16451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16453 if (SWIG_arg_fail(1)) SWIG_fail;
16454 {
16455 arg2 = (int)(SWIG_As_int(obj1));
16456 if (SWIG_arg_fail(2)) SWIG_fail;
16457 }
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 (arg1)->SetInt(arg2);
16461
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 Py_INCREF(Py_None); resultobj = Py_None;
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj;
16474 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16475 long result;
16476 PyObject * obj0 = 0 ;
16477 char *kwnames[] = {
16478 (char *) "self", NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16483 if (SWIG_arg_fail(1)) SWIG_fail;
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16487
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 {
16492 resultobj = SWIG_From_long((long)(result));
16493 }
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj;
16502 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16503 wxEvent *result;
16504 PyObject * obj0 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16527 PyObject *obj;
16528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16529 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16530 Py_INCREF(obj);
16531 return Py_BuildValue((char *)"");
16532 }
16533 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16536 int arg2 = (int) 0 ;
16537 wxNotifyEvent *result;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "commandType",(char *) "winid", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16545 if (obj0) {
16546 {
16547 arg1 = (wxEventType)(SWIG_As_int(obj0));
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 }
16550 }
16551 if (obj1) {
16552 {
16553 arg2 = (int)(SWIG_As_int(obj1));
16554 if (SWIG_arg_fail(2)) SWIG_fail;
16555 }
16556 }
16557 {
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj;
16573 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 (arg1)->Veto();
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 Py_INCREF(Py_None); resultobj = Py_None;
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16599 PyObject * obj0 = 0 ;
16600 char *kwnames[] = {
16601 (char *) "self", NULL
16602 };
16603
16604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16606 if (SWIG_arg_fail(1)) SWIG_fail;
16607 {
16608 PyThreadState* __tstate = wxPyBeginAllowThreads();
16609 (arg1)->Allow();
16610
16611 wxPyEndAllowThreads(__tstate);
16612 if (PyErr_Occurred()) SWIG_fail;
16613 }
16614 Py_INCREF(Py_None); resultobj = Py_None;
16615 return resultobj;
16616 fail:
16617 return NULL;
16618 }
16619
16620
16621 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj;
16623 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16624 bool result;
16625 PyObject * obj0 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "self", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16632 if (SWIG_arg_fail(1)) SWIG_fail;
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (bool)(arg1)->IsAllowed();
16636
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 {
16641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16642 }
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16650 PyObject *obj;
16651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16652 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16653 Py_INCREF(obj);
16654 return Py_BuildValue((char *)"");
16655 }
16656 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16657 PyObject *resultobj;
16658 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16659 int arg2 = (int) 0 ;
16660 int arg3 = (int) 0 ;
16661 int arg4 = (int) 0 ;
16662 wxScrollEvent *result;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 PyObject * obj3 = 0 ;
16667 char *kwnames[] = {
16668 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16669 };
16670
16671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16672 if (obj0) {
16673 {
16674 arg1 = (wxEventType)(SWIG_As_int(obj0));
16675 if (SWIG_arg_fail(1)) SWIG_fail;
16676 }
16677 }
16678 if (obj1) {
16679 {
16680 arg2 = (int)(SWIG_As_int(obj1));
16681 if (SWIG_arg_fail(2)) SWIG_fail;
16682 }
16683 }
16684 if (obj2) {
16685 {
16686 arg3 = (int)(SWIG_As_int(obj2));
16687 if (SWIG_arg_fail(3)) SWIG_fail;
16688 }
16689 }
16690 if (obj3) {
16691 {
16692 arg4 = (int)(SWIG_As_int(obj3));
16693 if (SWIG_arg_fail(4)) SWIG_fail;
16694 }
16695 }
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16699
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj;
16712 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16713 int result;
16714 PyObject * obj0 = 0 ;
16715 char *kwnames[] = {
16716 (char *) "self", NULL
16717 };
16718
16719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16721 if (SWIG_arg_fail(1)) SWIG_fail;
16722 {
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16725
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 {
16730 resultobj = SWIG_From_int((int)(result));
16731 }
16732 return resultobj;
16733 fail:
16734 return NULL;
16735 }
16736
16737
16738 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16739 PyObject *resultobj;
16740 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16741 int result;
16742 PyObject * obj0 = 0 ;
16743 char *kwnames[] = {
16744 (char *) "self", NULL
16745 };
16746
16747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16749 if (SWIG_arg_fail(1)) SWIG_fail;
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16753
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 {
16758 resultobj = SWIG_From_int((int)(result));
16759 }
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj;
16768 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16769 int arg2 ;
16770 PyObject * obj0 = 0 ;
16771 PyObject * obj1 = 0 ;
16772 char *kwnames[] = {
16773 (char *) "self",(char *) "orient", NULL
16774 };
16775
16776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16778 if (SWIG_arg_fail(1)) SWIG_fail;
16779 {
16780 arg2 = (int)(SWIG_As_int(obj1));
16781 if (SWIG_arg_fail(2)) SWIG_fail;
16782 }
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 (arg1)->SetOrientation(arg2);
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 Py_INCREF(Py_None); resultobj = Py_None;
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj;
16799 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16800 int arg2 ;
16801 PyObject * obj0 = 0 ;
16802 PyObject * obj1 = 0 ;
16803 char *kwnames[] = {
16804 (char *) "self",(char *) "pos", NULL
16805 };
16806
16807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16809 if (SWIG_arg_fail(1)) SWIG_fail;
16810 {
16811 arg2 = (int)(SWIG_As_int(obj1));
16812 if (SWIG_arg_fail(2)) SWIG_fail;
16813 }
16814 {
16815 PyThreadState* __tstate = wxPyBeginAllowThreads();
16816 (arg1)->SetPosition(arg2);
16817
16818 wxPyEndAllowThreads(__tstate);
16819 if (PyErr_Occurred()) SWIG_fail;
16820 }
16821 Py_INCREF(Py_None); resultobj = Py_None;
16822 return resultobj;
16823 fail:
16824 return NULL;
16825 }
16826
16827
16828 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16829 PyObject *obj;
16830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16831 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16832 Py_INCREF(obj);
16833 return Py_BuildValue((char *)"");
16834 }
16835 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16836 PyObject *resultobj;
16837 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16838 int arg2 = (int) 0 ;
16839 int arg3 = (int) 0 ;
16840 wxScrollWinEvent *result;
16841 PyObject * obj0 = 0 ;
16842 PyObject * obj1 = 0 ;
16843 PyObject * obj2 = 0 ;
16844 char *kwnames[] = {
16845 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16846 };
16847
16848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16849 if (obj0) {
16850 {
16851 arg1 = (wxEventType)(SWIG_As_int(obj0));
16852 if (SWIG_arg_fail(1)) SWIG_fail;
16853 }
16854 }
16855 if (obj1) {
16856 {
16857 arg2 = (int)(SWIG_As_int(obj1));
16858 if (SWIG_arg_fail(2)) SWIG_fail;
16859 }
16860 }
16861 if (obj2) {
16862 {
16863 arg3 = (int)(SWIG_As_int(obj2));
16864 if (SWIG_arg_fail(3)) SWIG_fail;
16865 }
16866 }
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16870
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj;
16883 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16884 int result;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16892 if (SWIG_arg_fail(1)) SWIG_fail;
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16896
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 {
16901 resultobj = SWIG_From_int((int)(result));
16902 }
16903 return resultobj;
16904 fail:
16905 return NULL;
16906 }
16907
16908
16909 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16910 PyObject *resultobj;
16911 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16912 int result;
16913 PyObject * obj0 = 0 ;
16914 char *kwnames[] = {
16915 (char *) "self", NULL
16916 };
16917
16918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16920 if (SWIG_arg_fail(1)) SWIG_fail;
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16924
16925 wxPyEndAllowThreads(__tstate);
16926 if (PyErr_Occurred()) SWIG_fail;
16927 }
16928 {
16929 resultobj = SWIG_From_int((int)(result));
16930 }
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj;
16939 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16940 int arg2 ;
16941 PyObject * obj0 = 0 ;
16942 PyObject * obj1 = 0 ;
16943 char *kwnames[] = {
16944 (char *) "self",(char *) "orient", NULL
16945 };
16946
16947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16949 if (SWIG_arg_fail(1)) SWIG_fail;
16950 {
16951 arg2 = (int)(SWIG_As_int(obj1));
16952 if (SWIG_arg_fail(2)) SWIG_fail;
16953 }
16954 {
16955 PyThreadState* __tstate = wxPyBeginAllowThreads();
16956 (arg1)->SetOrientation(arg2);
16957
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 Py_INCREF(Py_None); resultobj = Py_None;
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj;
16970 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16971 int arg2 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 char *kwnames[] = {
16975 (char *) "self",(char *) "pos", NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16980 if (SWIG_arg_fail(1)) SWIG_fail;
16981 {
16982 arg2 = (int)(SWIG_As_int(obj1));
16983 if (SWIG_arg_fail(2)) SWIG_fail;
16984 }
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 (arg1)->SetPosition(arg2);
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 Py_INCREF(Py_None); resultobj = Py_None;
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17000 PyObject *obj;
17001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17002 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17003 Py_INCREF(obj);
17004 return Py_BuildValue((char *)"");
17005 }
17006 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj;
17008 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17009 wxMouseEvent *result;
17010 PyObject * obj0 = 0 ;
17011 char *kwnames[] = {
17012 (char *) "mouseType", NULL
17013 };
17014
17015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17016 if (obj0) {
17017 {
17018 arg1 = (wxEventType)(SWIG_As_int(obj0));
17019 if (SWIG_arg_fail(1)) SWIG_fail;
17020 }
17021 }
17022 {
17023 PyThreadState* __tstate = wxPyBeginAllowThreads();
17024 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17025
17026 wxPyEndAllowThreads(__tstate);
17027 if (PyErr_Occurred()) SWIG_fail;
17028 }
17029 {
17030 resultobj = wxPyMake_wxObject(result, 1);
17031 }
17032 return resultobj;
17033 fail:
17034 return NULL;
17035 }
17036
17037
17038 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17039 PyObject *resultobj;
17040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17041 bool result;
17042 PyObject * obj0 = 0 ;
17043 char *kwnames[] = {
17044 (char *) "self", NULL
17045 };
17046
17047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17049 if (SWIG_arg_fail(1)) SWIG_fail;
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 {
17058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17059 }
17060 return resultobj;
17061 fail:
17062 return NULL;
17063 }
17064
17065
17066 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17067 PyObject *resultobj;
17068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17069 int arg2 = (int) wxMOUSE_BTN_ANY ;
17070 bool result;
17071 PyObject * obj0 = 0 ;
17072 PyObject * obj1 = 0 ;
17073 char *kwnames[] = {
17074 (char *) "self",(char *) "but", NULL
17075 };
17076
17077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17079 if (SWIG_arg_fail(1)) SWIG_fail;
17080 if (obj1) {
17081 {
17082 arg2 = (int)(SWIG_As_int(obj1));
17083 if (SWIG_arg_fail(2)) SWIG_fail;
17084 }
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17089
17090 wxPyEndAllowThreads(__tstate);
17091 if (PyErr_Occurred()) SWIG_fail;
17092 }
17093 {
17094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17095 }
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17105 int arg2 = (int) wxMOUSE_BTN_ANY ;
17106 bool result;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 char *kwnames[] = {
17110 (char *) "self",(char *) "but", NULL
17111 };
17112
17113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 if (obj1) {
17117 {
17118 arg2 = (int)(SWIG_As_int(obj1));
17119 if (SWIG_arg_fail(2)) SWIG_fail;
17120 }
17121 }
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17125
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 {
17130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17131 }
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj;
17140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17141 int arg2 = (int) wxMOUSE_BTN_ANY ;
17142 bool result;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "but", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 if (obj1) {
17153 {
17154 arg2 = (int)(SWIG_As_int(obj1));
17155 if (SWIG_arg_fail(2)) SWIG_fail;
17156 }
17157 }
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17161
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 {
17166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17167 }
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj;
17176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17177 int arg2 ;
17178 bool result;
17179 PyObject * obj0 = 0 ;
17180 PyObject * obj1 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self",(char *) "button", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 {
17189 arg2 = (int)(SWIG_As_int(obj1));
17190 if (SWIG_arg_fail(2)) SWIG_fail;
17191 }
17192 {
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17195
17196 wxPyEndAllowThreads(__tstate);
17197 if (PyErr_Occurred()) SWIG_fail;
17198 }
17199 {
17200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17201 }
17202 return resultobj;
17203 fail:
17204 return NULL;
17205 }
17206
17207
17208 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj;
17210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17211 int arg2 ;
17212 bool result;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self",(char *) "but", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 arg2 = (int)(SWIG_As_int(obj1));
17224 if (SWIG_arg_fail(2)) SWIG_fail;
17225 }
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17229
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 {
17234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17235 }
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj;
17244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17245 int result;
17246 PyObject * obj0 = 0 ;
17247 char *kwnames[] = {
17248 (char *) "self", NULL
17249 };
17250
17251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17253 if (SWIG_arg_fail(1)) SWIG_fail;
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17257
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = SWIG_From_int((int)(result));
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj;
17272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17273 bool result;
17274 PyObject * obj0 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 {
17290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17291 }
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17301 bool result;
17302 PyObject * obj0 = 0 ;
17303 char *kwnames[] = {
17304 (char *) "self", NULL
17305 };
17306
17307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17309 if (SWIG_arg_fail(1)) SWIG_fail;
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17313
17314 wxPyEndAllowThreads(__tstate);
17315 if (PyErr_Occurred()) SWIG_fail;
17316 }
17317 {
17318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17319 }
17320 return resultobj;
17321 fail:
17322 return NULL;
17323 }
17324
17325
17326 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 bool result;
17330 PyObject * obj0 = 0 ;
17331 char *kwnames[] = {
17332 (char *) "self", NULL
17333 };
17334
17335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17337 if (SWIG_arg_fail(1)) SWIG_fail;
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17341
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17347 }
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj;
17356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17357 bool result;
17358 PyObject * obj0 = 0 ;
17359 char *kwnames[] = {
17360 (char *) "self", NULL
17361 };
17362
17363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",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 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 {
17374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17375 }
17376 return resultobj;
17377 fail:
17378 return NULL;
17379 }
17380
17381
17382 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17383 PyObject *resultobj;
17384 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17385 bool result;
17386 PyObject * obj0 = 0 ;
17387 char *kwnames[] = {
17388 (char *) "self", NULL
17389 };
17390
17391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17393 if (SWIG_arg_fail(1)) SWIG_fail;
17394 {
17395 PyThreadState* __tstate = wxPyBeginAllowThreads();
17396 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17397
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17403 }
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17413 bool result;
17414 PyObject * obj0 = 0 ;
17415 char *kwnames[] = {
17416 (char *) "self", NULL
17417 };
17418
17419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17421 if (SWIG_arg_fail(1)) SWIG_fail;
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17425
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17431 }
17432 return resultobj;
17433 fail:
17434 return NULL;
17435 }
17436
17437
17438 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17439 PyObject *resultobj;
17440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17441 bool result;
17442 PyObject * obj0 = 0 ;
17443 char *kwnames[] = {
17444 (char *) "self", NULL
17445 };
17446
17447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17449 if (SWIG_arg_fail(1)) SWIG_fail;
17450 {
17451 PyThreadState* __tstate = wxPyBeginAllowThreads();
17452 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17453
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 {
17458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17459 }
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17467 PyObject *resultobj;
17468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17469 bool result;
17470 PyObject * obj0 = 0 ;
17471 char *kwnames[] = {
17472 (char *) "self", NULL
17473 };
17474
17475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17477 if (SWIG_arg_fail(1)) SWIG_fail;
17478 {
17479 PyThreadState* __tstate = wxPyBeginAllowThreads();
17480 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17481
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 {
17486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17487 }
17488 return resultobj;
17489 fail:
17490 return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17497 bool result;
17498 PyObject * obj0 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17505 if (SWIG_arg_fail(1)) SWIG_fail;
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17509
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 {
17514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj;
17524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17525 bool result;
17526 PyObject * obj0 = 0 ;
17527 char *kwnames[] = {
17528 (char *) "self", NULL
17529 };
17530
17531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17533 if (SWIG_arg_fail(1)) SWIG_fail;
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17537
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 {
17542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17543 }
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 bool result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17565
17566 wxPyEndAllowThreads(__tstate);
17567 if (PyErr_Occurred()) SWIG_fail;
17568 }
17569 {
17570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17571 }
17572 return resultobj;
17573 fail:
17574 return NULL;
17575 }
17576
17577
17578 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17579 PyObject *resultobj;
17580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17581 bool result;
17582 PyObject * obj0 = 0 ;
17583 char *kwnames[] = {
17584 (char *) "self", NULL
17585 };
17586
17587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17589 if (SWIG_arg_fail(1)) SWIG_fail;
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17599 }
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17609 bool result;
17610 PyObject * obj0 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17621
17622 wxPyEndAllowThreads(__tstate);
17623 if (PyErr_Occurred()) SWIG_fail;
17624 }
17625 {
17626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17627 }
17628 return resultobj;
17629 fail:
17630 return NULL;
17631 }
17632
17633
17634 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17635 PyObject *resultobj;
17636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17637 bool result;
17638 PyObject * obj0 = 0 ;
17639 char *kwnames[] = {
17640 (char *) "self", NULL
17641 };
17642
17643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17645 if (SWIG_arg_fail(1)) SWIG_fail;
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17649
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 {
17654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17655 }
17656 return resultobj;
17657 fail:
17658 return NULL;
17659 }
17660
17661
17662 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17663 PyObject *resultobj;
17664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17665 bool result;
17666 PyObject * obj0 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "self", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 {
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (bool)(arg1)->LeftIsDown();
17677
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 {
17682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17683 }
17684 return resultobj;
17685 fail:
17686 return NULL;
17687 }
17688
17689
17690 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17691 PyObject *resultobj;
17692 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17693 bool result;
17694 PyObject * obj0 = 0 ;
17695 char *kwnames[] = {
17696 (char *) "self", NULL
17697 };
17698
17699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17701 if (SWIG_arg_fail(1)) SWIG_fail;
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (bool)(arg1)->MiddleIsDown();
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj;
17720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17721 bool result;
17722 PyObject * obj0 = 0 ;
17723 char *kwnames[] = {
17724 (char *) "self", NULL
17725 };
17726
17727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17729 if (SWIG_arg_fail(1)) SWIG_fail;
17730 {
17731 PyThreadState* __tstate = wxPyBeginAllowThreads();
17732 result = (bool)(arg1)->RightIsDown();
17733
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 {
17738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17739 }
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 {
17766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17767 }
17768 return resultobj;
17769 fail:
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17777 bool result;
17778 PyObject * obj0 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "self", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17789
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 {
17794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17795 }
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj;
17804 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17805 bool result;
17806 PyObject * obj0 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17823 }
17824 return resultobj;
17825 fail:
17826 return NULL;
17827 }
17828
17829
17830 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17831 PyObject *resultobj;
17832 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17833 bool result;
17834 PyObject * obj0 = 0 ;
17835 char *kwnames[] = {
17836 (char *) "self", NULL
17837 };
17838
17839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17841 if (SWIG_arg_fail(1)) SWIG_fail;
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17845
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 {
17850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17851 }
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17859 PyObject *resultobj;
17860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17861 wxPoint result;
17862 PyObject * obj0 = 0 ;
17863 char *kwnames[] = {
17864 (char *) "self", NULL
17865 };
17866
17867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17869 if (SWIG_arg_fail(1)) SWIG_fail;
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 result = (arg1)->GetPosition();
17873
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 {
17878 wxPoint * resultptr;
17879 resultptr = new wxPoint((wxPoint &)(result));
17880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17881 }
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj;
17890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17891 long *arg2 = (long *) 0 ;
17892 long *arg3 = (long *) 0 ;
17893 long temp2 ;
17894 int res2 = 0 ;
17895 long temp3 ;
17896 int res3 = 0 ;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17903 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17906 if (SWIG_arg_fail(1)) SWIG_fail;
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 (arg1)->GetPosition(arg2,arg3);
17910
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 Py_INCREF(Py_None); resultobj = Py_None;
17915 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17916 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17917 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17918 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj;
17927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17928 wxDC *arg2 = 0 ;
17929 wxPoint result;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 char *kwnames[] = {
17933 (char *) "self",(char *) "dc", NULL
17934 };
17935
17936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17938 if (SWIG_arg_fail(1)) SWIG_fail;
17939 {
17940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17941 if (SWIG_arg_fail(2)) SWIG_fail;
17942 if (arg2 == NULL) {
17943 SWIG_null_ref("wxDC");
17944 }
17945 if (SWIG_arg_fail(2)) SWIG_fail;
17946 }
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17950
17951 wxPyEndAllowThreads(__tstate);
17952 if (PyErr_Occurred()) SWIG_fail;
17953 }
17954 {
17955 wxPoint * resultptr;
17956 resultptr = new wxPoint((wxPoint &)(result));
17957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17968 int result;
17969 PyObject * obj0 = 0 ;
17970 char *kwnames[] = {
17971 (char *) "self", NULL
17972 };
17973
17974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 {
17978 PyThreadState* __tstate = wxPyBeginAllowThreads();
17979 result = (int)((wxMouseEvent const *)arg1)->GetX();
17980
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 {
17985 resultobj = SWIG_From_int((int)(result));
17986 }
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj;
17995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17996 int result;
17997 PyObject * obj0 = 0 ;
17998 char *kwnames[] = {
17999 (char *) "self", NULL
18000 };
18001
18002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18004 if (SWIG_arg_fail(1)) SWIG_fail;
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 result = (int)((wxMouseEvent const *)arg1)->GetY();
18008
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 {
18013 resultobj = SWIG_From_int((int)(result));
18014 }
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18022 PyObject *resultobj;
18023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18024 int result;
18025 PyObject * obj0 = 0 ;
18026 char *kwnames[] = {
18027 (char *) "self", NULL
18028 };
18029
18030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18032 if (SWIG_arg_fail(1)) SWIG_fail;
18033 {
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18036
18037 wxPyEndAllowThreads(__tstate);
18038 if (PyErr_Occurred()) SWIG_fail;
18039 }
18040 {
18041 resultobj = SWIG_From_int((int)(result));
18042 }
18043 return resultobj;
18044 fail:
18045 return NULL;
18046 }
18047
18048
18049 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18050 PyObject *resultobj;
18051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18052 int result;
18053 PyObject * obj0 = 0 ;
18054 char *kwnames[] = {
18055 (char *) "self", NULL
18056 };
18057
18058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18060 if (SWIG_arg_fail(1)) SWIG_fail;
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18064
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 {
18069 resultobj = SWIG_From_int((int)(result));
18070 }
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj;
18079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18080 int result;
18081 PyObject * obj0 = 0 ;
18082 char *kwnames[] = {
18083 (char *) "self", NULL
18084 };
18085
18086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18088 if (SWIG_arg_fail(1)) SWIG_fail;
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18092
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 {
18097 resultobj = SWIG_From_int((int)(result));
18098 }
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18106 PyObject *resultobj;
18107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18108 bool result;
18109 PyObject * obj0 = 0 ;
18110 char *kwnames[] = {
18111 (char *) "self", NULL
18112 };
18113
18114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18116 if (SWIG_arg_fail(1)) SWIG_fail;
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj;
18135 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18136 int arg2 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char *kwnames[] = {
18140 (char *) "self",(char *) "m_x", NULL
18141 };
18142
18143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18145 if (SWIG_arg_fail(1)) SWIG_fail;
18146 {
18147 arg2 = (int)(SWIG_As_int(obj1));
18148 if (SWIG_arg_fail(2)) SWIG_fail;
18149 }
18150 if (arg1) (arg1)->m_x = arg2;
18151
18152 Py_INCREF(Py_None); resultobj = Py_None;
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18162 int result;
18163 PyObject * obj0 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 result = (int) ((arg1)->m_x);
18172
18173 {
18174 resultobj = SWIG_From_int((int)(result));
18175 }
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj;
18184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18185 int arg2 ;
18186 PyObject * obj0 = 0 ;
18187 PyObject * obj1 = 0 ;
18188 char *kwnames[] = {
18189 (char *) "self",(char *) "m_y", NULL
18190 };
18191
18192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18194 if (SWIG_arg_fail(1)) SWIG_fail;
18195 {
18196 arg2 = (int)(SWIG_As_int(obj1));
18197 if (SWIG_arg_fail(2)) SWIG_fail;
18198 }
18199 if (arg1) (arg1)->m_y = arg2;
18200
18201 Py_INCREF(Py_None); resultobj = Py_None;
18202 return resultobj;
18203 fail:
18204 return NULL;
18205 }
18206
18207
18208 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj;
18210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18211 int result;
18212 PyObject * obj0 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 result = (int) ((arg1)->m_y);
18221
18222 {
18223 resultobj = SWIG_From_int((int)(result));
18224 }
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18234 bool arg2 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 char *kwnames[] = {
18238 (char *) "self",(char *) "m_leftDown", NULL
18239 };
18240
18241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18243 if (SWIG_arg_fail(1)) SWIG_fail;
18244 {
18245 arg2 = (bool)(SWIG_As_bool(obj1));
18246 if (SWIG_arg_fail(2)) SWIG_fail;
18247 }
18248 if (arg1) (arg1)->m_leftDown = arg2;
18249
18250 Py_INCREF(Py_None); resultobj = Py_None;
18251 return resultobj;
18252 fail:
18253 return NULL;
18254 }
18255
18256
18257 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18258 PyObject *resultobj;
18259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18260 bool result;
18261 PyObject * obj0 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 result = (bool) ((arg1)->m_leftDown);
18270
18271 {
18272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18273 }
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj;
18282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18283 bool arg2 ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 char *kwnames[] = {
18287 (char *) "self",(char *) "m_middleDown", NULL
18288 };
18289
18290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18292 if (SWIG_arg_fail(1)) SWIG_fail;
18293 {
18294 arg2 = (bool)(SWIG_As_bool(obj1));
18295 if (SWIG_arg_fail(2)) SWIG_fail;
18296 }
18297 if (arg1) (arg1)->m_middleDown = arg2;
18298
18299 Py_INCREF(Py_None); resultobj = Py_None;
18300 return resultobj;
18301 fail:
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18309 bool result;
18310 PyObject * obj0 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 result = (bool) ((arg1)->m_middleDown);
18319
18320 {
18321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18322 }
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj;
18331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18332 bool arg2 ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char *kwnames[] = {
18336 (char *) "self",(char *) "m_rightDown", NULL
18337 };
18338
18339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18341 if (SWIG_arg_fail(1)) SWIG_fail;
18342 {
18343 arg2 = (bool)(SWIG_As_bool(obj1));
18344 if (SWIG_arg_fail(2)) SWIG_fail;
18345 }
18346 if (arg1) (arg1)->m_rightDown = arg2;
18347
18348 Py_INCREF(Py_None); resultobj = Py_None;
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj;
18357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18358 bool result;
18359 PyObject * obj0 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 result = (bool) ((arg1)->m_rightDown);
18368
18369 {
18370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18371 }
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj;
18380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18381 bool arg2 ;
18382 PyObject * obj0 = 0 ;
18383 PyObject * obj1 = 0 ;
18384 char *kwnames[] = {
18385 (char *) "self",(char *) "m_controlDown", NULL
18386 };
18387
18388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18390 if (SWIG_arg_fail(1)) SWIG_fail;
18391 {
18392 arg2 = (bool)(SWIG_As_bool(obj1));
18393 if (SWIG_arg_fail(2)) SWIG_fail;
18394 }
18395 if (arg1) (arg1)->m_controlDown = arg2;
18396
18397 Py_INCREF(Py_None); resultobj = Py_None;
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18405 PyObject *resultobj;
18406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18407 bool result;
18408 PyObject * obj0 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 result = (bool) ((arg1)->m_controlDown);
18417
18418 {
18419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18420 }
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj;
18429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18430 bool arg2 ;
18431 PyObject * obj0 = 0 ;
18432 PyObject * obj1 = 0 ;
18433 char *kwnames[] = {
18434 (char *) "self",(char *) "m_shiftDown", NULL
18435 };
18436
18437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18439 if (SWIG_arg_fail(1)) SWIG_fail;
18440 {
18441 arg2 = (bool)(SWIG_As_bool(obj1));
18442 if (SWIG_arg_fail(2)) SWIG_fail;
18443 }
18444 if (arg1) (arg1)->m_shiftDown = arg2;
18445
18446 Py_INCREF(Py_None); resultobj = Py_None;
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj;
18455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18456 bool result;
18457 PyObject * obj0 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 result = (bool) ((arg1)->m_shiftDown);
18466
18467 {
18468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18469 }
18470 return resultobj;
18471 fail:
18472 return NULL;
18473 }
18474
18475
18476 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj;
18478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18479 bool arg2 ;
18480 PyObject * obj0 = 0 ;
18481 PyObject * obj1 = 0 ;
18482 char *kwnames[] = {
18483 (char *) "self",(char *) "m_altDown", NULL
18484 };
18485
18486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18488 if (SWIG_arg_fail(1)) SWIG_fail;
18489 {
18490 arg2 = (bool)(SWIG_As_bool(obj1));
18491 if (SWIG_arg_fail(2)) SWIG_fail;
18492 }
18493 if (arg1) (arg1)->m_altDown = arg2;
18494
18495 Py_INCREF(Py_None); resultobj = Py_None;
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18505 bool result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 result = (bool) ((arg1)->m_altDown);
18515
18516 {
18517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18518 }
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18528 bool arg2 ;
18529 PyObject * obj0 = 0 ;
18530 PyObject * obj1 = 0 ;
18531 char *kwnames[] = {
18532 (char *) "self",(char *) "m_metaDown", NULL
18533 };
18534
18535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18537 if (SWIG_arg_fail(1)) SWIG_fail;
18538 {
18539 arg2 = (bool)(SWIG_As_bool(obj1));
18540 if (SWIG_arg_fail(2)) SWIG_fail;
18541 }
18542 if (arg1) (arg1)->m_metaDown = arg2;
18543
18544 Py_INCREF(Py_None); resultobj = Py_None;
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18552 PyObject *resultobj;
18553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18554 bool result;
18555 PyObject * obj0 = 0 ;
18556 char *kwnames[] = {
18557 (char *) "self", NULL
18558 };
18559
18560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18562 if (SWIG_arg_fail(1)) SWIG_fail;
18563 result = (bool) ((arg1)->m_metaDown);
18564
18565 {
18566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18567 }
18568 return resultobj;
18569 fail:
18570 return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj;
18576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18577 int arg2 ;
18578 PyObject * obj0 = 0 ;
18579 PyObject * obj1 = 0 ;
18580 char *kwnames[] = {
18581 (char *) "self",(char *) "m_wheelRotation", NULL
18582 };
18583
18584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18586 if (SWIG_arg_fail(1)) SWIG_fail;
18587 {
18588 arg2 = (int)(SWIG_As_int(obj1));
18589 if (SWIG_arg_fail(2)) SWIG_fail;
18590 }
18591 if (arg1) (arg1)->m_wheelRotation = arg2;
18592
18593 Py_INCREF(Py_None); resultobj = Py_None;
18594 return resultobj;
18595 fail:
18596 return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj;
18602 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18603 int result;
18604 PyObject * obj0 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "self", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18611 if (SWIG_arg_fail(1)) SWIG_fail;
18612 result = (int) ((arg1)->m_wheelRotation);
18613
18614 {
18615 resultobj = SWIG_From_int((int)(result));
18616 }
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj;
18625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18626 int arg2 ;
18627 PyObject * obj0 = 0 ;
18628 PyObject * obj1 = 0 ;
18629 char *kwnames[] = {
18630 (char *) "self",(char *) "m_wheelDelta", NULL
18631 };
18632
18633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18635 if (SWIG_arg_fail(1)) SWIG_fail;
18636 {
18637 arg2 = (int)(SWIG_As_int(obj1));
18638 if (SWIG_arg_fail(2)) SWIG_fail;
18639 }
18640 if (arg1) (arg1)->m_wheelDelta = arg2;
18641
18642 Py_INCREF(Py_None); resultobj = Py_None;
18643 return resultobj;
18644 fail:
18645 return NULL;
18646 }
18647
18648
18649 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18650 PyObject *resultobj;
18651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18652 int result;
18653 PyObject * obj0 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 result = (int) ((arg1)->m_wheelDelta);
18662
18663 {
18664 resultobj = SWIG_From_int((int)(result));
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18675 int arg2 ;
18676 PyObject * obj0 = 0 ;
18677 PyObject * obj1 = 0 ;
18678 char *kwnames[] = {
18679 (char *) "self",(char *) "m_linesPerAction", NULL
18680 };
18681
18682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18684 if (SWIG_arg_fail(1)) SWIG_fail;
18685 {
18686 arg2 = (int)(SWIG_As_int(obj1));
18687 if (SWIG_arg_fail(2)) SWIG_fail;
18688 }
18689 if (arg1) (arg1)->m_linesPerAction = arg2;
18690
18691 Py_INCREF(Py_None); resultobj = Py_None;
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18699 PyObject *resultobj;
18700 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18701 int result;
18702 PyObject * obj0 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 result = (int) ((arg1)->m_linesPerAction);
18711
18712 {
18713 resultobj = SWIG_From_int((int)(result));
18714 }
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18722 PyObject *obj;
18723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18724 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18725 Py_INCREF(obj);
18726 return Py_BuildValue((char *)"");
18727 }
18728 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18729 PyObject *resultobj;
18730 int arg1 = (int) 0 ;
18731 int arg2 = (int) 0 ;
18732 wxSetCursorEvent *result;
18733 PyObject * obj0 = 0 ;
18734 PyObject * obj1 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "x",(char *) "y", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18740 if (obj0) {
18741 {
18742 arg1 = (int)(SWIG_As_int(obj0));
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 }
18745 }
18746 if (obj1) {
18747 {
18748 arg2 = (int)(SWIG_As_int(obj1));
18749 if (SWIG_arg_fail(2)) SWIG_fail;
18750 }
18751 }
18752 {
18753 PyThreadState* __tstate = wxPyBeginAllowThreads();
18754 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18755
18756 wxPyEndAllowThreads(__tstate);
18757 if (PyErr_Occurred()) SWIG_fail;
18758 }
18759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18760 return resultobj;
18761 fail:
18762 return NULL;
18763 }
18764
18765
18766 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18767 PyObject *resultobj;
18768 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18769 int result;
18770 PyObject * obj0 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "self", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18777 if (SWIG_arg_fail(1)) SWIG_fail;
18778 {
18779 PyThreadState* __tstate = wxPyBeginAllowThreads();
18780 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18781
18782 wxPyEndAllowThreads(__tstate);
18783 if (PyErr_Occurred()) SWIG_fail;
18784 }
18785 {
18786 resultobj = SWIG_From_int((int)(result));
18787 }
18788 return resultobj;
18789 fail:
18790 return NULL;
18791 }
18792
18793
18794 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18795 PyObject *resultobj;
18796 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18797 int result;
18798 PyObject * obj0 = 0 ;
18799 char *kwnames[] = {
18800 (char *) "self", NULL
18801 };
18802
18803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18805 if (SWIG_arg_fail(1)) SWIG_fail;
18806 {
18807 PyThreadState* __tstate = wxPyBeginAllowThreads();
18808 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18809
18810 wxPyEndAllowThreads(__tstate);
18811 if (PyErr_Occurred()) SWIG_fail;
18812 }
18813 {
18814 resultobj = SWIG_From_int((int)(result));
18815 }
18816 return resultobj;
18817 fail:
18818 return NULL;
18819 }
18820
18821
18822 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18823 PyObject *resultobj;
18824 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18825 wxCursor *arg2 = 0 ;
18826 PyObject * obj0 = 0 ;
18827 PyObject * obj1 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self",(char *) "cursor", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 {
18836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18837 if (SWIG_arg_fail(2)) SWIG_fail;
18838 if (arg2 == NULL) {
18839 SWIG_null_ref("wxCursor");
18840 }
18841 if (SWIG_arg_fail(2)) SWIG_fail;
18842 }
18843 {
18844 PyThreadState* __tstate = wxPyBeginAllowThreads();
18845 (arg1)->SetCursor((wxCursor const &)*arg2);
18846
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 Py_INCREF(Py_None); resultobj = Py_None;
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj;
18859 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18860 wxCursor *result;
18861 PyObject * obj0 = 0 ;
18862 char *kwnames[] = {
18863 (char *) "self", NULL
18864 };
18865
18866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18868 if (SWIG_arg_fail(1)) SWIG_fail;
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 {
18872 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18873 result = (wxCursor *) &_result_ref;
18874 }
18875
18876 wxPyEndAllowThreads(__tstate);
18877 if (PyErr_Occurred()) SWIG_fail;
18878 }
18879 {
18880 wxCursor* resultptr = new wxCursor(*result);
18881 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18882 }
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18892 bool result;
18893 PyObject * obj0 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "self", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18900 if (SWIG_arg_fail(1)) SWIG_fail;
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18904
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 {
18909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18910 }
18911 return resultobj;
18912 fail:
18913 return NULL;
18914 }
18915
18916
18917 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18918 PyObject *obj;
18919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18920 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18921 Py_INCREF(obj);
18922 return Py_BuildValue((char *)"");
18923 }
18924 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj;
18926 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18927 wxKeyEvent *result;
18928 PyObject * obj0 = 0 ;
18929 char *kwnames[] = {
18930 (char *) "eventType", NULL
18931 };
18932
18933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18934 if (obj0) {
18935 {
18936 arg1 = (wxEventType)(SWIG_As_int(obj0));
18937 if (SWIG_arg_fail(1)) SWIG_fail;
18938 }
18939 }
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18943
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18955 PyObject *resultobj;
18956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18957 bool result;
18958 PyObject * obj0 = 0 ;
18959 char *kwnames[] = {
18960 (char *) "self", NULL
18961 };
18962
18963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18965 if (SWIG_arg_fail(1)) SWIG_fail;
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18969
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18975 }
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj;
18984 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18985 bool result;
18986 PyObject * obj0 = 0 ;
18987 char *kwnames[] = {
18988 (char *) "self", NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18993 if (SWIG_arg_fail(1)) SWIG_fail;
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18997
18998 wxPyEndAllowThreads(__tstate);
18999 if (PyErr_Occurred()) SWIG_fail;
19000 }
19001 {
19002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19003 }
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj;
19012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19013 bool result;
19014 PyObject * obj0 = 0 ;
19015 char *kwnames[] = {
19016 (char *) "self", NULL
19017 };
19018
19019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19021 if (SWIG_arg_fail(1)) SWIG_fail;
19022 {
19023 PyThreadState* __tstate = wxPyBeginAllowThreads();
19024 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19025
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 {
19030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19031 }
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19039 PyObject *resultobj;
19040 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19041 bool result;
19042 PyObject * obj0 = 0 ;
19043 char *kwnames[] = {
19044 (char *) "self", NULL
19045 };
19046
19047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19049 if (SWIG_arg_fail(1)) SWIG_fail;
19050 {
19051 PyThreadState* __tstate = wxPyBeginAllowThreads();
19052 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19053
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 {
19058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19059 }
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19067 PyObject *resultobj;
19068 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19069 bool result;
19070 PyObject * obj0 = 0 ;
19071 char *kwnames[] = {
19072 (char *) "self", NULL
19073 };
19074
19075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19077 if (SWIG_arg_fail(1)) SWIG_fail;
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19081
19082 wxPyEndAllowThreads(__tstate);
19083 if (PyErr_Occurred()) SWIG_fail;
19084 }
19085 {
19086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19087 }
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19095 PyObject *resultobj;
19096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19097 bool result;
19098 PyObject * obj0 = 0 ;
19099 char *kwnames[] = {
19100 (char *) "self", NULL
19101 };
19102
19103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19105 if (SWIG_arg_fail(1)) SWIG_fail;
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19109
19110 wxPyEndAllowThreads(__tstate);
19111 if (PyErr_Occurred()) SWIG_fail;
19112 }
19113 {
19114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19115 }
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19125 int result;
19126 PyObject * obj0 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "self", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 resultobj = SWIG_From_int((int)(result));
19143 }
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19151 PyObject *resultobj;
19152 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19153 int result;
19154 PyObject * obj0 = 0 ;
19155 char *kwnames[] = {
19156 (char *) "self", NULL
19157 };
19158
19159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19161 if (SWIG_arg_fail(1)) SWIG_fail;
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19165
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 {
19170 resultobj = SWIG_From_int((int)(result));
19171 }
19172 return resultobj;
19173 fail:
19174 return NULL;
19175 }
19176
19177
19178 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj;
19180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19181 unsigned int result;
19182 PyObject * obj0 = 0 ;
19183 char *kwnames[] = {
19184 (char *) "self", NULL
19185 };
19186
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 {
19198 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19199 }
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj;
19208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19209 unsigned int result;
19210 PyObject * obj0 = 0 ;
19211 char *kwnames[] = {
19212 (char *) "self", NULL
19213 };
19214
19215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19217 if (SWIG_arg_fail(1)) SWIG_fail;
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19221
19222 wxPyEndAllowThreads(__tstate);
19223 if (PyErr_Occurred()) SWIG_fail;
19224 }
19225 {
19226 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19227 }
19228 return resultobj;
19229 fail:
19230 return NULL;
19231 }
19232
19233
19234 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19235 PyObject *resultobj;
19236 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19237 wxPoint result;
19238 PyObject * obj0 = 0 ;
19239 char *kwnames[] = {
19240 (char *) "self", NULL
19241 };
19242
19243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19245 if (SWIG_arg_fail(1)) SWIG_fail;
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 result = (arg1)->GetPosition();
19249
19250 wxPyEndAllowThreads(__tstate);
19251 if (PyErr_Occurred()) SWIG_fail;
19252 }
19253 {
19254 wxPoint * resultptr;
19255 resultptr = new wxPoint((wxPoint &)(result));
19256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj;
19266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19267 long *arg2 = (long *) 0 ;
19268 long *arg3 = (long *) 0 ;
19269 long temp2 ;
19270 int res2 = 0 ;
19271 long temp3 ;
19272 int res3 = 0 ;
19273 PyObject * obj0 = 0 ;
19274 char *kwnames[] = {
19275 (char *) "self", NULL
19276 };
19277
19278 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19279 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19282 if (SWIG_arg_fail(1)) SWIG_fail;
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 (arg1)->GetPosition(arg2,arg3);
19286
19287 wxPyEndAllowThreads(__tstate);
19288 if (PyErr_Occurred()) SWIG_fail;
19289 }
19290 Py_INCREF(Py_None); resultobj = Py_None;
19291 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19292 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19293 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19294 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19302 PyObject *resultobj;
19303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19304 int result;
19305 PyObject * obj0 = 0 ;
19306 char *kwnames[] = {
19307 (char *) "self", NULL
19308 };
19309
19310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19312 if (SWIG_arg_fail(1)) SWIG_fail;
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (int)((wxKeyEvent const *)arg1)->GetX();
19316
19317 wxPyEndAllowThreads(__tstate);
19318 if (PyErr_Occurred()) SWIG_fail;
19319 }
19320 {
19321 resultobj = SWIG_From_int((int)(result));
19322 }
19323 return resultobj;
19324 fail:
19325 return NULL;
19326 }
19327
19328
19329 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj;
19331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19332 int result;
19333 PyObject * obj0 = 0 ;
19334 char *kwnames[] = {
19335 (char *) "self", NULL
19336 };
19337
19338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19340 if (SWIG_arg_fail(1)) SWIG_fail;
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = (int)((wxKeyEvent const *)arg1)->GetY();
19344
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 {
19349 resultobj = SWIG_From_int((int)(result));
19350 }
19351 return resultobj;
19352 fail:
19353 return NULL;
19354 }
19355
19356
19357 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19358 PyObject *resultobj;
19359 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19360 int arg2 ;
19361 PyObject * obj0 = 0 ;
19362 PyObject * obj1 = 0 ;
19363 char *kwnames[] = {
19364 (char *) "self",(char *) "m_x", NULL
19365 };
19366
19367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19369 if (SWIG_arg_fail(1)) SWIG_fail;
19370 {
19371 arg2 = (int)(SWIG_As_int(obj1));
19372 if (SWIG_arg_fail(2)) SWIG_fail;
19373 }
19374 if (arg1) (arg1)->m_x = arg2;
19375
19376 Py_INCREF(Py_None); resultobj = Py_None;
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19384 PyObject *resultobj;
19385 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19386 int result;
19387 PyObject * obj0 = 0 ;
19388 char *kwnames[] = {
19389 (char *) "self", NULL
19390 };
19391
19392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19394 if (SWIG_arg_fail(1)) SWIG_fail;
19395 result = (int) ((arg1)->m_x);
19396
19397 {
19398 resultobj = SWIG_From_int((int)(result));
19399 }
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj;
19408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19409 int arg2 ;
19410 PyObject * obj0 = 0 ;
19411 PyObject * obj1 = 0 ;
19412 char *kwnames[] = {
19413 (char *) "self",(char *) "m_y", NULL
19414 };
19415
19416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19418 if (SWIG_arg_fail(1)) SWIG_fail;
19419 {
19420 arg2 = (int)(SWIG_As_int(obj1));
19421 if (SWIG_arg_fail(2)) SWIG_fail;
19422 }
19423 if (arg1) (arg1)->m_y = arg2;
19424
19425 Py_INCREF(Py_None); resultobj = Py_None;
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj;
19434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19435 int result;
19436 PyObject * obj0 = 0 ;
19437 char *kwnames[] = {
19438 (char *) "self", NULL
19439 };
19440
19441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19443 if (SWIG_arg_fail(1)) SWIG_fail;
19444 result = (int) ((arg1)->m_y);
19445
19446 {
19447 resultobj = SWIG_From_int((int)(result));
19448 }
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19456 PyObject *resultobj;
19457 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19458 long arg2 ;
19459 PyObject * obj0 = 0 ;
19460 PyObject * obj1 = 0 ;
19461 char *kwnames[] = {
19462 (char *) "self",(char *) "m_keyCode", NULL
19463 };
19464
19465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19467 if (SWIG_arg_fail(1)) SWIG_fail;
19468 {
19469 arg2 = (long)(SWIG_As_long(obj1));
19470 if (SWIG_arg_fail(2)) SWIG_fail;
19471 }
19472 if (arg1) (arg1)->m_keyCode = arg2;
19473
19474 Py_INCREF(Py_None); resultobj = Py_None;
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19484 long result;
19485 PyObject * obj0 = 0 ;
19486 char *kwnames[] = {
19487 (char *) "self", NULL
19488 };
19489
19490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19492 if (SWIG_arg_fail(1)) SWIG_fail;
19493 result = (long) ((arg1)->m_keyCode);
19494
19495 {
19496 resultobj = SWIG_From_long((long)(result));
19497 }
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj;
19506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19507 bool arg2 ;
19508 PyObject * obj0 = 0 ;
19509 PyObject * obj1 = 0 ;
19510 char *kwnames[] = {
19511 (char *) "self",(char *) "m_controlDown", NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19516 if (SWIG_arg_fail(1)) SWIG_fail;
19517 {
19518 arg2 = (bool)(SWIG_As_bool(obj1));
19519 if (SWIG_arg_fail(2)) SWIG_fail;
19520 }
19521 if (arg1) (arg1)->m_controlDown = arg2;
19522
19523 Py_INCREF(Py_None); resultobj = Py_None;
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19531 PyObject *resultobj;
19532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19533 bool result;
19534 PyObject * obj0 = 0 ;
19535 char *kwnames[] = {
19536 (char *) "self", NULL
19537 };
19538
19539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19541 if (SWIG_arg_fail(1)) SWIG_fail;
19542 result = (bool) ((arg1)->m_controlDown);
19543
19544 {
19545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19546 }
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj;
19555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19556 bool arg2 ;
19557 PyObject * obj0 = 0 ;
19558 PyObject * obj1 = 0 ;
19559 char *kwnames[] = {
19560 (char *) "self",(char *) "m_shiftDown", NULL
19561 };
19562
19563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19565 if (SWIG_arg_fail(1)) SWIG_fail;
19566 {
19567 arg2 = (bool)(SWIG_As_bool(obj1));
19568 if (SWIG_arg_fail(2)) SWIG_fail;
19569 }
19570 if (arg1) (arg1)->m_shiftDown = arg2;
19571
19572 Py_INCREF(Py_None); resultobj = Py_None;
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj;
19581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19582 bool result;
19583 PyObject * obj0 = 0 ;
19584 char *kwnames[] = {
19585 (char *) "self", NULL
19586 };
19587
19588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19590 if (SWIG_arg_fail(1)) SWIG_fail;
19591 result = (bool) ((arg1)->m_shiftDown);
19592
19593 {
19594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19595 }
19596 return resultobj;
19597 fail:
19598 return NULL;
19599 }
19600
19601
19602 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19603 PyObject *resultobj;
19604 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19605 bool arg2 ;
19606 PyObject * obj0 = 0 ;
19607 PyObject * obj1 = 0 ;
19608 char *kwnames[] = {
19609 (char *) "self",(char *) "m_altDown", NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19614 if (SWIG_arg_fail(1)) SWIG_fail;
19615 {
19616 arg2 = (bool)(SWIG_As_bool(obj1));
19617 if (SWIG_arg_fail(2)) SWIG_fail;
19618 }
19619 if (arg1) (arg1)->m_altDown = arg2;
19620
19621 Py_INCREF(Py_None); resultobj = Py_None;
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj;
19630 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19631 bool result;
19632 PyObject * obj0 = 0 ;
19633 char *kwnames[] = {
19634 (char *) "self", NULL
19635 };
19636
19637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19639 if (SWIG_arg_fail(1)) SWIG_fail;
19640 result = (bool) ((arg1)->m_altDown);
19641
19642 {
19643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19654 bool arg2 ;
19655 PyObject * obj0 = 0 ;
19656 PyObject * obj1 = 0 ;
19657 char *kwnames[] = {
19658 (char *) "self",(char *) "m_metaDown", NULL
19659 };
19660
19661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19663 if (SWIG_arg_fail(1)) SWIG_fail;
19664 {
19665 arg2 = (bool)(SWIG_As_bool(obj1));
19666 if (SWIG_arg_fail(2)) SWIG_fail;
19667 }
19668 if (arg1) (arg1)->m_metaDown = arg2;
19669
19670 Py_INCREF(Py_None); resultobj = Py_None;
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj;
19679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19680 bool result;
19681 PyObject * obj0 = 0 ;
19682 char *kwnames[] = {
19683 (char *) "self", NULL
19684 };
19685
19686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 result = (bool) ((arg1)->m_metaDown);
19690
19691 {
19692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19693 }
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19703 bool arg2 ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 char *kwnames[] = {
19707 (char *) "self",(char *) "m_scanCode", NULL
19708 };
19709
19710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19712 if (SWIG_arg_fail(1)) SWIG_fail;
19713 {
19714 arg2 = (bool)(SWIG_As_bool(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 if (arg1) (arg1)->m_scanCode = arg2;
19718
19719 Py_INCREF(Py_None); resultobj = Py_None;
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19727 PyObject *resultobj;
19728 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19729 bool result;
19730 PyObject * obj0 = 0 ;
19731 char *kwnames[] = {
19732 (char *) "self", NULL
19733 };
19734
19735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 result = (bool) ((arg1)->m_scanCode);
19739
19740 {
19741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19742 }
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj;
19751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19752 unsigned int arg2 ;
19753 PyObject * obj0 = 0 ;
19754 PyObject * obj1 = 0 ;
19755 char *kwnames[] = {
19756 (char *) "self",(char *) "m_rawCode", NULL
19757 };
19758
19759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19761 if (SWIG_arg_fail(1)) SWIG_fail;
19762 {
19763 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19764 if (SWIG_arg_fail(2)) SWIG_fail;
19765 }
19766 if (arg1) (arg1)->m_rawCode = arg2;
19767
19768 Py_INCREF(Py_None); resultobj = Py_None;
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj;
19777 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19778 unsigned int result;
19779 PyObject * obj0 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 result = (unsigned int) ((arg1)->m_rawCode);
19788
19789 {
19790 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19791 }
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj;
19800 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19801 unsigned int arg2 ;
19802 PyObject * obj0 = 0 ;
19803 PyObject * obj1 = 0 ;
19804 char *kwnames[] = {
19805 (char *) "self",(char *) "m_rawFlags", NULL
19806 };
19807
19808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19810 if (SWIG_arg_fail(1)) SWIG_fail;
19811 {
19812 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19813 if (SWIG_arg_fail(2)) SWIG_fail;
19814 }
19815 if (arg1) (arg1)->m_rawFlags = arg2;
19816
19817 Py_INCREF(Py_None); resultobj = Py_None;
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj;
19826 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19827 unsigned int result;
19828 PyObject * obj0 = 0 ;
19829 char *kwnames[] = {
19830 (char *) "self", NULL
19831 };
19832
19833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19835 if (SWIG_arg_fail(1)) SWIG_fail;
19836 result = (unsigned int) ((arg1)->m_rawFlags);
19837
19838 {
19839 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19840 }
19841 return resultobj;
19842 fail:
19843 return NULL;
19844 }
19845
19846
19847 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19848 PyObject *obj;
19849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19850 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19851 Py_INCREF(obj);
19852 return Py_BuildValue((char *)"");
19853 }
19854 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19855 PyObject *resultobj;
19856 wxSize const &arg1_defvalue = wxDefaultSize ;
19857 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19858 int arg2 = (int) 0 ;
19859 wxSizeEvent *result;
19860 wxSize temp1 ;
19861 PyObject * obj0 = 0 ;
19862 PyObject * obj1 = 0 ;
19863 char *kwnames[] = {
19864 (char *) "sz",(char *) "winid", NULL
19865 };
19866
19867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19868 if (obj0) {
19869 {
19870 arg1 = &temp1;
19871 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19872 }
19873 }
19874 if (obj1) {
19875 {
19876 arg2 = (int)(SWIG_As_int(obj1));
19877 if (SWIG_arg_fail(2)) SWIG_fail;
19878 }
19879 }
19880 {
19881 PyThreadState* __tstate = wxPyBeginAllowThreads();
19882 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19883
19884 wxPyEndAllowThreads(__tstate);
19885 if (PyErr_Occurred()) SWIG_fail;
19886 }
19887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19888 return resultobj;
19889 fail:
19890 return NULL;
19891 }
19892
19893
19894 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj;
19896 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19897 wxSize result;
19898 PyObject * obj0 = 0 ;
19899 char *kwnames[] = {
19900 (char *) "self", NULL
19901 };
19902
19903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19905 if (SWIG_arg_fail(1)) SWIG_fail;
19906 {
19907 PyThreadState* __tstate = wxPyBeginAllowThreads();
19908 result = ((wxSizeEvent const *)arg1)->GetSize();
19909
19910 wxPyEndAllowThreads(__tstate);
19911 if (PyErr_Occurred()) SWIG_fail;
19912 }
19913 {
19914 wxSize * resultptr;
19915 resultptr = new wxSize((wxSize &)(result));
19916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19917 }
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19927 wxRect result;
19928 PyObject * obj0 = 0 ;
19929 char *kwnames[] = {
19930 (char *) "self", NULL
19931 };
19932
19933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19935 if (SWIG_arg_fail(1)) SWIG_fail;
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = ((wxSizeEvent const *)arg1)->GetRect();
19939
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 {
19944 wxRect * resultptr;
19945 resultptr = new wxRect((wxRect &)(result));
19946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19947 }
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19955 PyObject *resultobj;
19956 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19957 wxRect arg2 ;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self",(char *) "rect", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 wxRect * argp;
19969 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19970 if (SWIG_arg_fail(2)) SWIG_fail;
19971 if (argp == NULL) {
19972 SWIG_null_ref("wxRect");
19973 }
19974 if (SWIG_arg_fail(2)) SWIG_fail;
19975 arg2 = *argp;
19976 }
19977 {
19978 PyThreadState* __tstate = wxPyBeginAllowThreads();
19979 (arg1)->SetRect(arg2);
19980
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 Py_INCREF(Py_None); resultobj = Py_None;
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19992 PyObject *resultobj;
19993 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19994 wxSize arg2 ;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "self",(char *) "size", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20003 if (SWIG_arg_fail(1)) SWIG_fail;
20004 {
20005 wxSize * argp;
20006 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20007 if (SWIG_arg_fail(2)) SWIG_fail;
20008 if (argp == NULL) {
20009 SWIG_null_ref("wxSize");
20010 }
20011 if (SWIG_arg_fail(2)) SWIG_fail;
20012 arg2 = *argp;
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 wxSizeEvent_SetSize(arg1,arg2);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 Py_INCREF(Py_None); resultobj = Py_None;
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20031 wxSize *arg2 = (wxSize *) 0 ;
20032 PyObject * obj0 = 0 ;
20033 PyObject * obj1 = 0 ;
20034 char *kwnames[] = {
20035 (char *) "self",(char *) "m_size", NULL
20036 };
20037
20038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20040 if (SWIG_arg_fail(1)) SWIG_fail;
20041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20042 if (SWIG_arg_fail(2)) SWIG_fail;
20043 if (arg1) (arg1)->m_size = *arg2;
20044
20045 Py_INCREF(Py_None); resultobj = Py_None;
20046 return resultobj;
20047 fail:
20048 return NULL;
20049 }
20050
20051
20052 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20053 PyObject *resultobj;
20054 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20055 wxSize *result;
20056 PyObject * obj0 = 0 ;
20057 char *kwnames[] = {
20058 (char *) "self", NULL
20059 };
20060
20061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20063 if (SWIG_arg_fail(1)) SWIG_fail;
20064 result = (wxSize *)& ((arg1)->m_size);
20065
20066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20074 PyObject *resultobj;
20075 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20076 wxRect *arg2 = (wxRect *) 0 ;
20077 PyObject * obj0 = 0 ;
20078 PyObject * obj1 = 0 ;
20079 char *kwnames[] = {
20080 (char *) "self",(char *) "m_rect", NULL
20081 };
20082
20083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20085 if (SWIG_arg_fail(1)) SWIG_fail;
20086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20087 if (SWIG_arg_fail(2)) SWIG_fail;
20088 if (arg1) (arg1)->m_rect = *arg2;
20089
20090 Py_INCREF(Py_None); resultobj = Py_None;
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20098 PyObject *resultobj;
20099 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20100 wxRect *result;
20101 PyObject * obj0 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 result = (wxRect *)& ((arg1)->m_rect);
20110
20111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20112 return resultobj;
20113 fail:
20114 return NULL;
20115 }
20116
20117
20118 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20119 PyObject *obj;
20120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20121 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20122 Py_INCREF(obj);
20123 return Py_BuildValue((char *)"");
20124 }
20125 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20126 PyObject *resultobj;
20127 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20128 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20129 int arg2 = (int) 0 ;
20130 wxMoveEvent *result;
20131 wxPoint temp1 ;
20132 PyObject * obj0 = 0 ;
20133 PyObject * obj1 = 0 ;
20134 char *kwnames[] = {
20135 (char *) "pos",(char *) "winid", NULL
20136 };
20137
20138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20139 if (obj0) {
20140 {
20141 arg1 = &temp1;
20142 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20143 }
20144 }
20145 if (obj1) {
20146 {
20147 arg2 = (int)(SWIG_As_int(obj1));
20148 if (SWIG_arg_fail(2)) SWIG_fail;
20149 }
20150 }
20151 {
20152 PyThreadState* __tstate = wxPyBeginAllowThreads();
20153 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20154
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20159 return resultobj;
20160 fail:
20161 return NULL;
20162 }
20163
20164
20165 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20166 PyObject *resultobj;
20167 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20168 wxPoint result;
20169 PyObject * obj0 = 0 ;
20170 char *kwnames[] = {
20171 (char *) "self", NULL
20172 };
20173
20174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20176 if (SWIG_arg_fail(1)) SWIG_fail;
20177 {
20178 PyThreadState* __tstate = wxPyBeginAllowThreads();
20179 result = ((wxMoveEvent const *)arg1)->GetPosition();
20180
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 {
20185 wxPoint * resultptr;
20186 resultptr = new wxPoint((wxPoint &)(result));
20187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20188 }
20189 return resultobj;
20190 fail:
20191 return NULL;
20192 }
20193
20194
20195 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj;
20197 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20198 wxRect result;
20199 PyObject * obj0 = 0 ;
20200 char *kwnames[] = {
20201 (char *) "self", NULL
20202 };
20203
20204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20206 if (SWIG_arg_fail(1)) SWIG_fail;
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = ((wxMoveEvent const *)arg1)->GetRect();
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 {
20215 wxRect * resultptr;
20216 resultptr = new wxRect((wxRect &)(result));
20217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20218 }
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20226 PyObject *resultobj;
20227 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20228 wxRect *arg2 = 0 ;
20229 wxRect temp2 ;
20230 PyObject * obj0 = 0 ;
20231 PyObject * obj1 = 0 ;
20232 char *kwnames[] = {
20233 (char *) "self",(char *) "rect", NULL
20234 };
20235
20236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20238 if (SWIG_arg_fail(1)) SWIG_fail;
20239 {
20240 arg2 = &temp2;
20241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20242 }
20243 {
20244 PyThreadState* __tstate = wxPyBeginAllowThreads();
20245 (arg1)->SetRect((wxRect const &)*arg2);
20246
20247 wxPyEndAllowThreads(__tstate);
20248 if (PyErr_Occurred()) SWIG_fail;
20249 }
20250 Py_INCREF(Py_None); resultobj = Py_None;
20251 return resultobj;
20252 fail:
20253 return NULL;
20254 }
20255
20256
20257 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20258 PyObject *resultobj;
20259 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20260 wxPoint *arg2 = 0 ;
20261 wxPoint temp2 ;
20262 PyObject * obj0 = 0 ;
20263 PyObject * obj1 = 0 ;
20264 char *kwnames[] = {
20265 (char *) "self",(char *) "pos", NULL
20266 };
20267
20268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20270 if (SWIG_arg_fail(1)) SWIG_fail;
20271 {
20272 arg2 = &temp2;
20273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20274 }
20275 {
20276 PyThreadState* __tstate = wxPyBeginAllowThreads();
20277 (arg1)->SetPosition((wxPoint const &)*arg2);
20278
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 Py_INCREF(Py_None); resultobj = Py_None;
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20290 PyObject *obj;
20291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20292 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20293 Py_INCREF(obj);
20294 return Py_BuildValue((char *)"");
20295 }
20296 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 int arg1 = (int) 0 ;
20299 wxPaintEvent *result;
20300 PyObject * obj0 = 0 ;
20301 char *kwnames[] = {
20302 (char *) "Id", NULL
20303 };
20304
20305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20306 if (obj0) {
20307 {
20308 arg1 = (int)(SWIG_As_int(obj0));
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 }
20311 }
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20315
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20327 PyObject *obj;
20328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20329 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20330 Py_INCREF(obj);
20331 return Py_BuildValue((char *)"");
20332 }
20333 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj;
20335 int arg1 = (int) 0 ;
20336 wxNcPaintEvent *result;
20337 PyObject * obj0 = 0 ;
20338 char *kwnames[] = {
20339 (char *) "winid", NULL
20340 };
20341
20342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20343 if (obj0) {
20344 {
20345 arg1 = (int)(SWIG_As_int(obj0));
20346 if (SWIG_arg_fail(1)) SWIG_fail;
20347 }
20348 }
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20364 PyObject *obj;
20365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20366 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20367 Py_INCREF(obj);
20368 return Py_BuildValue((char *)"");
20369 }
20370 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20371 PyObject *resultobj;
20372 int arg1 = (int) 0 ;
20373 wxDC *arg2 = (wxDC *) NULL ;
20374 wxEraseEvent *result;
20375 PyObject * obj0 = 0 ;
20376 PyObject * obj1 = 0 ;
20377 char *kwnames[] = {
20378 (char *) "Id",(char *) "dc", NULL
20379 };
20380
20381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20382 if (obj0) {
20383 {
20384 arg1 = (int)(SWIG_As_int(obj0));
20385 if (SWIG_arg_fail(1)) SWIG_fail;
20386 }
20387 }
20388 if (obj1) {
20389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20390 if (SWIG_arg_fail(2)) SWIG_fail;
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20395
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20400 return resultobj;
20401 fail:
20402 return NULL;
20403 }
20404
20405
20406 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20407 PyObject *resultobj;
20408 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20409 wxDC *result;
20410 PyObject * obj0 = 0 ;
20411 char *kwnames[] = {
20412 (char *) "self", NULL
20413 };
20414
20415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20417 if (SWIG_arg_fail(1)) SWIG_fail;
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20421
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 {
20426 resultobj = wxPyMake_wxObject(result, 0);
20427 }
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20435 PyObject *obj;
20436 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20437 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20438 Py_INCREF(obj);
20439 return Py_BuildValue((char *)"");
20440 }
20441 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20442 PyObject *resultobj;
20443 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20444 int arg2 = (int) 0 ;
20445 wxFocusEvent *result;
20446 PyObject * obj0 = 0 ;
20447 PyObject * obj1 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "type",(char *) "winid", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20453 if (obj0) {
20454 {
20455 arg1 = (wxEventType)(SWIG_As_int(obj0));
20456 if (SWIG_arg_fail(1)) SWIG_fail;
20457 }
20458 }
20459 if (obj1) {
20460 {
20461 arg2 = (int)(SWIG_As_int(obj1));
20462 if (SWIG_arg_fail(2)) SWIG_fail;
20463 }
20464 }
20465 {
20466 PyThreadState* __tstate = wxPyBeginAllowThreads();
20467 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20468
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20480 PyObject *resultobj;
20481 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20482 wxWindow *result;
20483 PyObject * obj0 = 0 ;
20484 char *kwnames[] = {
20485 (char *) "self", NULL
20486 };
20487
20488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20490 if (SWIG_arg_fail(1)) SWIG_fail;
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20494
20495 wxPyEndAllowThreads(__tstate);
20496 if (PyErr_Occurred()) SWIG_fail;
20497 }
20498 {
20499 resultobj = wxPyMake_wxObject(result, 0);
20500 }
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20508 PyObject *resultobj;
20509 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20510 wxWindow *arg2 = (wxWindow *) 0 ;
20511 PyObject * obj0 = 0 ;
20512 PyObject * obj1 = 0 ;
20513 char *kwnames[] = {
20514 (char *) "self",(char *) "win", NULL
20515 };
20516
20517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20519 if (SWIG_arg_fail(1)) SWIG_fail;
20520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20521 if (SWIG_arg_fail(2)) SWIG_fail;
20522 {
20523 PyThreadState* __tstate = wxPyBeginAllowThreads();
20524 (arg1)->SetWindow(arg2);
20525
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 Py_INCREF(Py_None); resultobj = Py_None;
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20537 PyObject *obj;
20538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20539 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20540 Py_INCREF(obj);
20541 return Py_BuildValue((char *)"");
20542 }
20543 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20544 PyObject *resultobj;
20545 wxWindow *arg1 = (wxWindow *) NULL ;
20546 wxChildFocusEvent *result;
20547 PyObject * obj0 = 0 ;
20548 char *kwnames[] = {
20549 (char *) "win", NULL
20550 };
20551
20552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20553 if (obj0) {
20554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20555 if (SWIG_arg_fail(1)) SWIG_fail;
20556 }
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20560
20561 wxPyEndAllowThreads(__tstate);
20562 if (PyErr_Occurred()) SWIG_fail;
20563 }
20564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj;
20573 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20574 wxWindow *result;
20575 PyObject * obj0 = 0 ;
20576 char *kwnames[] = {
20577 (char *) "self", NULL
20578 };
20579
20580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20582 if (SWIG_arg_fail(1)) SWIG_fail;
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20586
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = wxPyMake_wxObject(result, 0);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20600 PyObject *obj;
20601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20602 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20603 Py_INCREF(obj);
20604 return Py_BuildValue((char *)"");
20605 }
20606 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj;
20608 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20609 bool arg2 = (bool) true ;
20610 int arg3 = (int) 0 ;
20611 wxActivateEvent *result;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 PyObject * obj2 = 0 ;
20615 char *kwnames[] = {
20616 (char *) "type",(char *) "active",(char *) "Id", NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20620 if (obj0) {
20621 {
20622 arg1 = (wxEventType)(SWIG_As_int(obj0));
20623 if (SWIG_arg_fail(1)) SWIG_fail;
20624 }
20625 }
20626 if (obj1) {
20627 {
20628 arg2 = (bool)(SWIG_As_bool(obj1));
20629 if (SWIG_arg_fail(2)) SWIG_fail;
20630 }
20631 }
20632 if (obj2) {
20633 {
20634 arg3 = (int)(SWIG_As_int(obj2));
20635 if (SWIG_arg_fail(3)) SWIG_fail;
20636 }
20637 }
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20641
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20655 bool result;
20656 PyObject * obj0 = 0 ;
20657 char *kwnames[] = {
20658 (char *) "self", NULL
20659 };
20660
20661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20663 if (SWIG_arg_fail(1)) SWIG_fail;
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20667
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 {
20672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20673 }
20674 return resultobj;
20675 fail:
20676 return NULL;
20677 }
20678
20679
20680 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20681 PyObject *obj;
20682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20683 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20684 Py_INCREF(obj);
20685 return Py_BuildValue((char *)"");
20686 }
20687 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj;
20689 int arg1 = (int) 0 ;
20690 wxInitDialogEvent *result;
20691 PyObject * obj0 = 0 ;
20692 char *kwnames[] = {
20693 (char *) "Id", NULL
20694 };
20695
20696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20697 if (obj0) {
20698 {
20699 arg1 = (int)(SWIG_As_int(obj0));
20700 if (SWIG_arg_fail(1)) SWIG_fail;
20701 }
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20718 PyObject *obj;
20719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20720 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20721 Py_INCREF(obj);
20722 return Py_BuildValue((char *)"");
20723 }
20724 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20725 PyObject *resultobj;
20726 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20727 int arg2 = (int) 0 ;
20728 wxMenu *arg3 = (wxMenu *) NULL ;
20729 wxMenuEvent *result;
20730 PyObject * obj0 = 0 ;
20731 PyObject * obj1 = 0 ;
20732 PyObject * obj2 = 0 ;
20733 char *kwnames[] = {
20734 (char *) "type",(char *) "winid",(char *) "menu", NULL
20735 };
20736
20737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20738 if (obj0) {
20739 {
20740 arg1 = (wxEventType)(SWIG_As_int(obj0));
20741 if (SWIG_arg_fail(1)) SWIG_fail;
20742 }
20743 }
20744 if (obj1) {
20745 {
20746 arg2 = (int)(SWIG_As_int(obj1));
20747 if (SWIG_arg_fail(2)) SWIG_fail;
20748 }
20749 }
20750 if (obj2) {
20751 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20752 if (SWIG_arg_fail(3)) SWIG_fail;
20753 }
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20757
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj;
20770 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20771 int result;
20772 PyObject * obj0 = 0 ;
20773 char *kwnames[] = {
20774 (char *) "self", NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20779 if (SWIG_arg_fail(1)) SWIG_fail;
20780 {
20781 PyThreadState* __tstate = wxPyBeginAllowThreads();
20782 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20783
20784 wxPyEndAllowThreads(__tstate);
20785 if (PyErr_Occurred()) SWIG_fail;
20786 }
20787 {
20788 resultobj = SWIG_From_int((int)(result));
20789 }
20790 return resultobj;
20791 fail:
20792 return NULL;
20793 }
20794
20795
20796 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj;
20798 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20799 bool result;
20800 PyObject * obj0 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "self", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20807 if (SWIG_arg_fail(1)) SWIG_fail;
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 {
20816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20817 }
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj;
20826 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20827 wxMenu *result;
20828 PyObject * obj0 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "self", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(1)) SWIG_fail;
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20839
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 {
20844 resultobj = wxPyMake_wxObject(result, 0);
20845 }
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20853 PyObject *obj;
20854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20855 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20856 Py_INCREF(obj);
20857 return Py_BuildValue((char *)"");
20858 }
20859 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20860 PyObject *resultobj;
20861 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20862 int arg2 = (int) 0 ;
20863 wxCloseEvent *result;
20864 PyObject * obj0 = 0 ;
20865 PyObject * obj1 = 0 ;
20866 char *kwnames[] = {
20867 (char *) "type",(char *) "winid", NULL
20868 };
20869
20870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20871 if (obj0) {
20872 {
20873 arg1 = (wxEventType)(SWIG_As_int(obj0));
20874 if (SWIG_arg_fail(1)) SWIG_fail;
20875 }
20876 }
20877 if (obj1) {
20878 {
20879 arg2 = (int)(SWIG_As_int(obj1));
20880 if (SWIG_arg_fail(2)) SWIG_fail;
20881 }
20882 }
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20900 bool arg2 ;
20901 PyObject * obj0 = 0 ;
20902 PyObject * obj1 = 0 ;
20903 char *kwnames[] = {
20904 (char *) "self",(char *) "logOff", NULL
20905 };
20906
20907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20909 if (SWIG_arg_fail(1)) SWIG_fail;
20910 {
20911 arg2 = (bool)(SWIG_As_bool(obj1));
20912 if (SWIG_arg_fail(2)) SWIG_fail;
20913 }
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 (arg1)->SetLoggingOff(arg2);
20917
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 Py_INCREF(Py_None); resultobj = Py_None;
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj;
20930 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20931 bool result;
20932 PyObject * obj0 = 0 ;
20933 char *kwnames[] = {
20934 (char *) "self", NULL
20935 };
20936
20937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20939 if (SWIG_arg_fail(1)) SWIG_fail;
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20943
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 {
20948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20949 }
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20957 PyObject *resultobj;
20958 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20959 bool arg2 = (bool) true ;
20960 PyObject * obj0 = 0 ;
20961 PyObject * obj1 = 0 ;
20962 char *kwnames[] = {
20963 (char *) "self",(char *) "veto", NULL
20964 };
20965
20966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20968 if (SWIG_arg_fail(1)) SWIG_fail;
20969 if (obj1) {
20970 {
20971 arg2 = (bool)(SWIG_As_bool(obj1));
20972 if (SWIG_arg_fail(2)) SWIG_fail;
20973 }
20974 }
20975 {
20976 PyThreadState* __tstate = wxPyBeginAllowThreads();
20977 (arg1)->Veto(arg2);
20978
20979 wxPyEndAllowThreads(__tstate);
20980 if (PyErr_Occurred()) SWIG_fail;
20981 }
20982 Py_INCREF(Py_None); resultobj = Py_None;
20983 return resultobj;
20984 fail:
20985 return NULL;
20986 }
20987
20988
20989 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20990 PyObject *resultobj;
20991 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20992 bool result;
20993 PyObject * obj0 = 0 ;
20994 char *kwnames[] = {
20995 (char *) "self", NULL
20996 };
20997
20998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21000 if (SWIG_arg_fail(1)) SWIG_fail;
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21004
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 {
21009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21010 }
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj;
21019 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21020 bool arg2 ;
21021 PyObject * obj0 = 0 ;
21022 PyObject * obj1 = 0 ;
21023 char *kwnames[] = {
21024 (char *) "self",(char *) "canVeto", NULL
21025 };
21026
21027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21029 if (SWIG_arg_fail(1)) SWIG_fail;
21030 {
21031 arg2 = (bool)(SWIG_As_bool(obj1));
21032 if (SWIG_arg_fail(2)) SWIG_fail;
21033 }
21034 {
21035 PyThreadState* __tstate = wxPyBeginAllowThreads();
21036 (arg1)->SetCanVeto(arg2);
21037
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 Py_INCREF(Py_None); resultobj = Py_None;
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21049 PyObject *resultobj;
21050 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21051 bool result;
21052 PyObject * obj0 = 0 ;
21053 char *kwnames[] = {
21054 (char *) "self", NULL
21055 };
21056
21057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21059 if (SWIG_arg_fail(1)) SWIG_fail;
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21063
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21077 PyObject *obj;
21078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21079 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21080 Py_INCREF(obj);
21081 return Py_BuildValue((char *)"");
21082 }
21083 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21084 PyObject *resultobj;
21085 int arg1 = (int) 0 ;
21086 bool arg2 = (bool) false ;
21087 wxShowEvent *result;
21088 PyObject * obj0 = 0 ;
21089 PyObject * obj1 = 0 ;
21090 char *kwnames[] = {
21091 (char *) "winid",(char *) "show", NULL
21092 };
21093
21094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21095 if (obj0) {
21096 {
21097 arg1 = (int)(SWIG_As_int(obj0));
21098 if (SWIG_arg_fail(1)) SWIG_fail;
21099 }
21100 }
21101 if (obj1) {
21102 {
21103 arg2 = (bool)(SWIG_As_bool(obj1));
21104 if (SWIG_arg_fail(2)) SWIG_fail;
21105 }
21106 }
21107 {
21108 PyThreadState* __tstate = wxPyBeginAllowThreads();
21109 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21110
21111 wxPyEndAllowThreads(__tstate);
21112 if (PyErr_Occurred()) SWIG_fail;
21113 }
21114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21122 PyObject *resultobj;
21123 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21124 bool arg2 ;
21125 PyObject * obj0 = 0 ;
21126 PyObject * obj1 = 0 ;
21127 char *kwnames[] = {
21128 (char *) "self",(char *) "show", NULL
21129 };
21130
21131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21133 if (SWIG_arg_fail(1)) SWIG_fail;
21134 {
21135 arg2 = (bool)(SWIG_As_bool(obj1));
21136 if (SWIG_arg_fail(2)) SWIG_fail;
21137 }
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 (arg1)->SetShow(arg2);
21141
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 Py_INCREF(Py_None); resultobj = Py_None;
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21155 bool result;
21156 PyObject * obj0 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "self", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 {
21165 PyThreadState* __tstate = wxPyBeginAllowThreads();
21166 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21167
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 {
21172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21181 PyObject *obj;
21182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21183 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21184 Py_INCREF(obj);
21185 return Py_BuildValue((char *)"");
21186 }
21187 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj;
21189 int arg1 = (int) 0 ;
21190 bool arg2 = (bool) true ;
21191 wxIconizeEvent *result;
21192 PyObject * obj0 = 0 ;
21193 PyObject * obj1 = 0 ;
21194 char *kwnames[] = {
21195 (char *) "id",(char *) "iconized", NULL
21196 };
21197
21198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21199 if (obj0) {
21200 {
21201 arg1 = (int)(SWIG_As_int(obj0));
21202 if (SWIG_arg_fail(1)) SWIG_fail;
21203 }
21204 }
21205 if (obj1) {
21206 {
21207 arg2 = (bool)(SWIG_As_bool(obj1));
21208 if (SWIG_arg_fail(2)) SWIG_fail;
21209 }
21210 }
21211 {
21212 PyThreadState* __tstate = wxPyBeginAllowThreads();
21213 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21214
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj;
21227 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21228 bool result;
21229 PyObject * obj0 = 0 ;
21230 char *kwnames[] = {
21231 (char *) "self", NULL
21232 };
21233
21234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(1)) SWIG_fail;
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 result = (bool)(arg1)->Iconized();
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 {
21245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21254 PyObject *obj;
21255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21256 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21257 Py_INCREF(obj);
21258 return Py_BuildValue((char *)"");
21259 }
21260 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj;
21262 int arg1 = (int) 0 ;
21263 wxMaximizeEvent *result;
21264 PyObject * obj0 = 0 ;
21265 char *kwnames[] = {
21266 (char *) "id", NULL
21267 };
21268
21269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21270 if (obj0) {
21271 {
21272 arg1 = (int)(SWIG_As_int(obj0));
21273 if (SWIG_arg_fail(1)) SWIG_fail;
21274 }
21275 }
21276 {
21277 PyThreadState* __tstate = wxPyBeginAllowThreads();
21278 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21279
21280 wxPyEndAllowThreads(__tstate);
21281 if (PyErr_Occurred()) SWIG_fail;
21282 }
21283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21291 PyObject *obj;
21292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21293 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21294 Py_INCREF(obj);
21295 return Py_BuildValue((char *)"");
21296 }
21297 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21300 wxPoint result;
21301 PyObject * obj0 = 0 ;
21302 char *kwnames[] = {
21303 (char *) "self", NULL
21304 };
21305
21306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (arg1)->GetPosition();
21312
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 wxPoint * resultptr;
21318 resultptr = new wxPoint((wxPoint &)(result));
21319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21320 }
21321 return resultobj;
21322 fail:
21323 return NULL;
21324 }
21325
21326
21327 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21328 PyObject *resultobj;
21329 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21330 int result;
21331 PyObject * obj0 = 0 ;
21332 char *kwnames[] = {
21333 (char *) "self", NULL
21334 };
21335
21336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21338 if (SWIG_arg_fail(1)) SWIG_fail;
21339 {
21340 PyThreadState* __tstate = wxPyBeginAllowThreads();
21341 result = (int)(arg1)->GetNumberOfFiles();
21342
21343 wxPyEndAllowThreads(__tstate);
21344 if (PyErr_Occurred()) SWIG_fail;
21345 }
21346 {
21347 resultobj = SWIG_From_int((int)(result));
21348 }
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21358 PyObject *result;
21359 PyObject * obj0 = 0 ;
21360 char *kwnames[] = {
21361 (char *) "self", NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21366 if (SWIG_arg_fail(1)) SWIG_fail;
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21370
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 resultobj = result;
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21382 PyObject *obj;
21383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21384 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21385 Py_INCREF(obj);
21386 return Py_BuildValue((char *)"");
21387 }
21388 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 int arg1 = (int) 0 ;
21391 wxUpdateUIEvent *result;
21392 PyObject * obj0 = 0 ;
21393 char *kwnames[] = {
21394 (char *) "commandId", NULL
21395 };
21396
21397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21398 if (obj0) {
21399 {
21400 arg1 = (int)(SWIG_As_int(obj0));
21401 if (SWIG_arg_fail(1)) SWIG_fail;
21402 }
21403 }
21404 {
21405 PyThreadState* __tstate = wxPyBeginAllowThreads();
21406 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21407
21408 wxPyEndAllowThreads(__tstate);
21409 if (PyErr_Occurred()) SWIG_fail;
21410 }
21411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21412 return resultobj;
21413 fail:
21414 return NULL;
21415 }
21416
21417
21418 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21419 PyObject *resultobj;
21420 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21421 bool result;
21422 PyObject * obj0 = 0 ;
21423 char *kwnames[] = {
21424 (char *) "self", NULL
21425 };
21426
21427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21429 if (SWIG_arg_fail(1)) SWIG_fail;
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21433
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 {
21438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21439 }
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21447 PyObject *resultobj;
21448 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21449 bool result;
21450 PyObject * obj0 = 0 ;
21451 char *kwnames[] = {
21452 (char *) "self", NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21457 if (SWIG_arg_fail(1)) SWIG_fail;
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 {
21466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21467 }
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj;
21476 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21477 wxString result;
21478 PyObject * obj0 = 0 ;
21479 char *kwnames[] = {
21480 (char *) "self", NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21485 if (SWIG_arg_fail(1)) SWIG_fail;
21486 {
21487 PyThreadState* __tstate = wxPyBeginAllowThreads();
21488 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21489
21490 wxPyEndAllowThreads(__tstate);
21491 if (PyErr_Occurred()) SWIG_fail;
21492 }
21493 {
21494 #if wxUSE_UNICODE
21495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21496 #else
21497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21498 #endif
21499 }
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj;
21508 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21509 bool result;
21510 PyObject * obj0 = 0 ;
21511 char *kwnames[] = {
21512 (char *) "self", NULL
21513 };
21514
21515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21517 if (SWIG_arg_fail(1)) SWIG_fail;
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21527 }
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21535 PyObject *resultobj;
21536 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21537 bool result;
21538 PyObject * obj0 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 {
21554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21555 }
21556 return resultobj;
21557 fail:
21558 return NULL;
21559 }
21560
21561
21562 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21563 PyObject *resultobj;
21564 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21565 bool result;
21566 PyObject * obj0 = 0 ;
21567 char *kwnames[] = {
21568 (char *) "self", NULL
21569 };
21570
21571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21573 if (SWIG_arg_fail(1)) SWIG_fail;
21574 {
21575 PyThreadState* __tstate = wxPyBeginAllowThreads();
21576 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21577
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 {
21582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21583 }
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj;
21592 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21593 bool arg2 ;
21594 PyObject * obj0 = 0 ;
21595 PyObject * obj1 = 0 ;
21596 char *kwnames[] = {
21597 (char *) "self",(char *) "check", NULL
21598 };
21599
21600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21602 if (SWIG_arg_fail(1)) SWIG_fail;
21603 {
21604 arg2 = (bool)(SWIG_As_bool(obj1));
21605 if (SWIG_arg_fail(2)) SWIG_fail;
21606 }
21607 {
21608 PyThreadState* __tstate = wxPyBeginAllowThreads();
21609 (arg1)->Check(arg2);
21610
21611 wxPyEndAllowThreads(__tstate);
21612 if (PyErr_Occurred()) SWIG_fail;
21613 }
21614 Py_INCREF(Py_None); resultobj = Py_None;
21615 return resultobj;
21616 fail:
21617 return NULL;
21618 }
21619
21620
21621 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21622 PyObject *resultobj;
21623 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21624 bool arg2 ;
21625 PyObject * obj0 = 0 ;
21626 PyObject * obj1 = 0 ;
21627 char *kwnames[] = {
21628 (char *) "self",(char *) "enable", NULL
21629 };
21630
21631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21633 if (SWIG_arg_fail(1)) SWIG_fail;
21634 {
21635 arg2 = (bool)(SWIG_As_bool(obj1));
21636 if (SWIG_arg_fail(2)) SWIG_fail;
21637 }
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 (arg1)->Enable(arg2);
21641
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 Py_INCREF(Py_None); resultobj = Py_None;
21646 return resultobj;
21647 fail:
21648 return NULL;
21649 }
21650
21651
21652 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj;
21654 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21655 wxString *arg2 = 0 ;
21656 bool temp2 = false ;
21657 PyObject * obj0 = 0 ;
21658 PyObject * obj1 = 0 ;
21659 char *kwnames[] = {
21660 (char *) "self",(char *) "text", NULL
21661 };
21662
21663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21665 if (SWIG_arg_fail(1)) SWIG_fail;
21666 {
21667 arg2 = wxString_in_helper(obj1);
21668 if (arg2 == NULL) SWIG_fail;
21669 temp2 = true;
21670 }
21671 {
21672 PyThreadState* __tstate = wxPyBeginAllowThreads();
21673 (arg1)->SetText((wxString const &)*arg2);
21674
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 Py_INCREF(Py_None); resultobj = Py_None;
21679 {
21680 if (temp2)
21681 delete arg2;
21682 }
21683 return resultobj;
21684 fail:
21685 {
21686 if (temp2)
21687 delete arg2;
21688 }
21689 return NULL;
21690 }
21691
21692
21693 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21694 PyObject *resultobj;
21695 long arg1 ;
21696 PyObject * obj0 = 0 ;
21697 char *kwnames[] = {
21698 (char *) "updateInterval", NULL
21699 };
21700
21701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21702 {
21703 arg1 = (long)(SWIG_As_long(obj0));
21704 if (SWIG_arg_fail(1)) SWIG_fail;
21705 }
21706 {
21707 PyThreadState* __tstate = wxPyBeginAllowThreads();
21708 wxUpdateUIEvent::SetUpdateInterval(arg1);
21709
21710 wxPyEndAllowThreads(__tstate);
21711 if (PyErr_Occurred()) SWIG_fail;
21712 }
21713 Py_INCREF(Py_None); resultobj = Py_None;
21714 return resultobj;
21715 fail:
21716 return NULL;
21717 }
21718
21719
21720 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21721 PyObject *resultobj;
21722 long result;
21723 char *kwnames[] = {
21724 NULL
21725 };
21726
21727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = SWIG_From_long((long)(result));
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxWindow *arg1 = (wxWindow *) 0 ;
21747 bool result;
21748 PyObject * obj0 = 0 ;
21749 char *kwnames[] = {
21750 (char *) "win", NULL
21751 };
21752
21753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21755 if (SWIG_arg_fail(1)) SWIG_fail;
21756 {
21757 PyThreadState* __tstate = wxPyBeginAllowThreads();
21758 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21759
21760 wxPyEndAllowThreads(__tstate);
21761 if (PyErr_Occurred()) SWIG_fail;
21762 }
21763 {
21764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21765 }
21766 return resultobj;
21767 fail:
21768 return NULL;
21769 }
21770
21771
21772 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj;
21774 char *kwnames[] = {
21775 NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 wxUpdateUIEvent::ResetUpdateTime();
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 Py_INCREF(Py_None); resultobj = Py_None;
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxUpdateUIMode arg1 ;
21796 PyObject * obj0 = 0 ;
21797 char *kwnames[] = {
21798 (char *) "mode", NULL
21799 };
21800
21801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21802 {
21803 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 }
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21809
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 Py_INCREF(Py_None); resultobj = Py_None;
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21821 PyObject *resultobj;
21822 wxUpdateUIMode result;
21823 char *kwnames[] = {
21824 NULL
21825 };
21826
21827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21831
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 resultobj = SWIG_From_int((result));
21836 return resultobj;
21837 fail:
21838 return NULL;
21839 }
21840
21841
21842 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21843 PyObject *obj;
21844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21845 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21846 Py_INCREF(obj);
21847 return Py_BuildValue((char *)"");
21848 }
21849 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj;
21851 wxSysColourChangedEvent *result;
21852 char *kwnames[] = {
21853 NULL
21854 };
21855
21856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21860
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21872 PyObject *obj;
21873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21874 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21875 Py_INCREF(obj);
21876 return Py_BuildValue((char *)"");
21877 }
21878 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj;
21880 int arg1 = (int) 0 ;
21881 wxWindow *arg2 = (wxWindow *) NULL ;
21882 wxMouseCaptureChangedEvent *result;
21883 PyObject * obj0 = 0 ;
21884 PyObject * obj1 = 0 ;
21885 char *kwnames[] = {
21886 (char *) "winid",(char *) "gainedCapture", NULL
21887 };
21888
21889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21890 if (obj0) {
21891 {
21892 arg1 = (int)(SWIG_As_int(obj0));
21893 if (SWIG_arg_fail(1)) SWIG_fail;
21894 }
21895 }
21896 if (obj1) {
21897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 }
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj;
21916 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21917 wxWindow *result;
21918 PyObject * obj0 = 0 ;
21919 char *kwnames[] = {
21920 (char *) "self", NULL
21921 };
21922
21923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21925 if (SWIG_arg_fail(1)) SWIG_fail;
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21929
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = wxPyMake_wxObject(result, 0);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21943 PyObject *obj;
21944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21945 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21946 Py_INCREF(obj);
21947 return Py_BuildValue((char *)"");
21948 }
21949 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj;
21951 wxDisplayChangedEvent *result;
21952 char *kwnames[] = {
21953 NULL
21954 };
21955
21956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21960
21961 wxPyEndAllowThreads(__tstate);
21962 if (PyErr_Occurred()) SWIG_fail;
21963 }
21964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21965 return resultobj;
21966 fail:
21967 return NULL;
21968 }
21969
21970
21971 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21972 PyObject *obj;
21973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21974 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21975 Py_INCREF(obj);
21976 return Py_BuildValue((char *)"");
21977 }
21978 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 int arg1 = (int) 0 ;
21981 wxPaletteChangedEvent *result;
21982 PyObject * obj0 = 0 ;
21983 char *kwnames[] = {
21984 (char *) "id", NULL
21985 };
21986
21987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21988 if (obj0) {
21989 {
21990 arg1 = (int)(SWIG_As_int(obj0));
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 }
21993 }
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21997
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22002 return resultobj;
22003 fail:
22004 return NULL;
22005 }
22006
22007
22008 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22009 PyObject *resultobj;
22010 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22011 wxWindow *arg2 = (wxWindow *) 0 ;
22012 PyObject * obj0 = 0 ;
22013 PyObject * obj1 = 0 ;
22014 char *kwnames[] = {
22015 (char *) "self",(char *) "win", NULL
22016 };
22017
22018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22020 if (SWIG_arg_fail(1)) SWIG_fail;
22021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22022 if (SWIG_arg_fail(2)) SWIG_fail;
22023 {
22024 PyThreadState* __tstate = wxPyBeginAllowThreads();
22025 (arg1)->SetChangedWindow(arg2);
22026
22027 wxPyEndAllowThreads(__tstate);
22028 if (PyErr_Occurred()) SWIG_fail;
22029 }
22030 Py_INCREF(Py_None); resultobj = Py_None;
22031 return resultobj;
22032 fail:
22033 return NULL;
22034 }
22035
22036
22037 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22038 PyObject *resultobj;
22039 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22040 wxWindow *result;
22041 PyObject * obj0 = 0 ;
22042 char *kwnames[] = {
22043 (char *) "self", NULL
22044 };
22045
22046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22048 if (SWIG_arg_fail(1)) SWIG_fail;
22049 {
22050 PyThreadState* __tstate = wxPyBeginAllowThreads();
22051 result = (wxWindow *)(arg1)->GetChangedWindow();
22052
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 {
22057 resultobj = wxPyMake_wxObject(result, 0);
22058 }
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22066 PyObject *obj;
22067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22068 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22069 Py_INCREF(obj);
22070 return Py_BuildValue((char *)"");
22071 }
22072 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22073 PyObject *resultobj;
22074 int arg1 = (int) 0 ;
22075 wxQueryNewPaletteEvent *result;
22076 PyObject * obj0 = 0 ;
22077 char *kwnames[] = {
22078 (char *) "winid", NULL
22079 };
22080
22081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22082 if (obj0) {
22083 {
22084 arg1 = (int)(SWIG_As_int(obj0));
22085 if (SWIG_arg_fail(1)) SWIG_fail;
22086 }
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22105 bool arg2 ;
22106 PyObject * obj0 = 0 ;
22107 PyObject * obj1 = 0 ;
22108 char *kwnames[] = {
22109 (char *) "self",(char *) "realized", NULL
22110 };
22111
22112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22114 if (SWIG_arg_fail(1)) SWIG_fail;
22115 {
22116 arg2 = (bool)(SWIG_As_bool(obj1));
22117 if (SWIG_arg_fail(2)) SWIG_fail;
22118 }
22119 {
22120 PyThreadState* __tstate = wxPyBeginAllowThreads();
22121 (arg1)->SetPaletteRealized(arg2);
22122
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 Py_INCREF(Py_None); resultobj = Py_None;
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj;
22135 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22136 bool result;
22137 PyObject * obj0 = 0 ;
22138 char *kwnames[] = {
22139 (char *) "self", NULL
22140 };
22141
22142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22144 if (SWIG_arg_fail(1)) SWIG_fail;
22145 {
22146 PyThreadState* __tstate = wxPyBeginAllowThreads();
22147 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22148
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 {
22153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22154 }
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22162 PyObject *obj;
22163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22164 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22165 Py_INCREF(obj);
22166 return Py_BuildValue((char *)"");
22167 }
22168 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22169 PyObject *resultobj;
22170 wxNavigationKeyEvent *result;
22171 char *kwnames[] = {
22172 NULL
22173 };
22174
22175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22179
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22184 return resultobj;
22185 fail:
22186 return NULL;
22187 }
22188
22189
22190 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22191 PyObject *resultobj;
22192 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22193 bool result;
22194 PyObject * obj0 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 {
22210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22211 }
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22219 PyObject *resultobj;
22220 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22221 bool arg2 ;
22222 PyObject * obj0 = 0 ;
22223 PyObject * obj1 = 0 ;
22224 char *kwnames[] = {
22225 (char *) "self",(char *) "forward", NULL
22226 };
22227
22228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(1)) SWIG_fail;
22231 {
22232 arg2 = (bool)(SWIG_As_bool(obj1));
22233 if (SWIG_arg_fail(2)) SWIG_fail;
22234 }
22235 {
22236 PyThreadState* __tstate = wxPyBeginAllowThreads();
22237 (arg1)->SetDirection(arg2);
22238
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 Py_INCREF(Py_None); resultobj = Py_None;
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22250 PyObject *resultobj;
22251 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22252 bool result;
22253 PyObject * obj0 = 0 ;
22254 char *kwnames[] = {
22255 (char *) "self", NULL
22256 };
22257
22258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22264
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 {
22269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22270 }
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj;
22279 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22280 bool arg2 ;
22281 PyObject * obj0 = 0 ;
22282 PyObject * obj1 = 0 ;
22283 char *kwnames[] = {
22284 (char *) "self",(char *) "ischange", NULL
22285 };
22286
22287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(1)) SWIG_fail;
22290 {
22291 arg2 = (bool)(SWIG_As_bool(obj1));
22292 if (SWIG_arg_fail(2)) SWIG_fail;
22293 }
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 (arg1)->SetWindowChange(arg2);
22297
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 Py_INCREF(Py_None); resultobj = Py_None;
22302 return resultobj;
22303 fail:
22304 return NULL;
22305 }
22306
22307
22308 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22309 PyObject *resultobj;
22310 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22311 bool result;
22312 PyObject * obj0 = 0 ;
22313 char *kwnames[] = {
22314 (char *) "self", NULL
22315 };
22316
22317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22319 if (SWIG_arg_fail(1)) SWIG_fail;
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22323
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 {
22328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22329 }
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj;
22338 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22339 bool arg2 ;
22340 PyObject * obj0 = 0 ;
22341 PyObject * obj1 = 0 ;
22342 char *kwnames[] = {
22343 (char *) "self",(char *) "bIs", NULL
22344 };
22345
22346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(1)) SWIG_fail;
22349 {
22350 arg2 = (bool)(SWIG_As_bool(obj1));
22351 if (SWIG_arg_fail(2)) SWIG_fail;
22352 }
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 (arg1)->SetFromTab(arg2);
22356
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 Py_INCREF(Py_None); resultobj = Py_None;
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22368 PyObject *resultobj;
22369 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22370 long arg2 ;
22371 PyObject * obj0 = 0 ;
22372 PyObject * obj1 = 0 ;
22373 char *kwnames[] = {
22374 (char *) "self",(char *) "flags", NULL
22375 };
22376
22377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22379 if (SWIG_arg_fail(1)) SWIG_fail;
22380 {
22381 arg2 = (long)(SWIG_As_long(obj1));
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 }
22384 {
22385 PyThreadState* __tstate = wxPyBeginAllowThreads();
22386 (arg1)->SetFlags(arg2);
22387
22388 wxPyEndAllowThreads(__tstate);
22389 if (PyErr_Occurred()) SWIG_fail;
22390 }
22391 Py_INCREF(Py_None); resultobj = Py_None;
22392 return resultobj;
22393 fail:
22394 return NULL;
22395 }
22396
22397
22398 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22399 PyObject *resultobj;
22400 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22401 wxWindow *result;
22402 PyObject * obj0 = 0 ;
22403 char *kwnames[] = {
22404 (char *) "self", NULL
22405 };
22406
22407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22409 if (SWIG_arg_fail(1)) SWIG_fail;
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22413
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 {
22418 resultobj = wxPyMake_wxObject(result, 0);
22419 }
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22427 PyObject *resultobj;
22428 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22429 wxWindow *arg2 = (wxWindow *) 0 ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self",(char *) "win", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22440 if (SWIG_arg_fail(2)) SWIG_fail;
22441 {
22442 PyThreadState* __tstate = wxPyBeginAllowThreads();
22443 (arg1)->SetCurrentFocus(arg2);
22444
22445 wxPyEndAllowThreads(__tstate);
22446 if (PyErr_Occurred()) SWIG_fail;
22447 }
22448 Py_INCREF(Py_None); resultobj = Py_None;
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22456 PyObject *obj;
22457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22458 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22459 Py_INCREF(obj);
22460 return Py_BuildValue((char *)"");
22461 }
22462 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22463 PyObject *resultobj;
22464 wxWindow *arg1 = (wxWindow *) NULL ;
22465 wxWindowCreateEvent *result;
22466 PyObject * obj0 = 0 ;
22467 char *kwnames[] = {
22468 (char *) "win", NULL
22469 };
22470
22471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22472 if (obj0) {
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 }
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22484 return resultobj;
22485 fail:
22486 return NULL;
22487 }
22488
22489
22490 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22491 PyObject *resultobj;
22492 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22493 wxWindow *result;
22494 PyObject * obj0 = 0 ;
22495 char *kwnames[] = {
22496 (char *) "self", NULL
22497 };
22498
22499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22501 if (SWIG_arg_fail(1)) SWIG_fail;
22502 {
22503 PyThreadState* __tstate = wxPyBeginAllowThreads();
22504 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 {
22510 resultobj = wxPyMake_wxObject(result, 0);
22511 }
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22519 PyObject *obj;
22520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22521 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22522 Py_INCREF(obj);
22523 return Py_BuildValue((char *)"");
22524 }
22525 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22526 PyObject *resultobj;
22527 wxWindow *arg1 = (wxWindow *) NULL ;
22528 wxWindowDestroyEvent *result;
22529 PyObject * obj0 = 0 ;
22530 char *kwnames[] = {
22531 (char *) "win", NULL
22532 };
22533
22534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22535 if (obj0) {
22536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22537 if (SWIG_arg_fail(1)) SWIG_fail;
22538 }
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22542
22543 wxPyEndAllowThreads(__tstate);
22544 if (PyErr_Occurred()) SWIG_fail;
22545 }
22546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22554 PyObject *resultobj;
22555 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22556 wxWindow *result;
22557 PyObject * obj0 = 0 ;
22558 char *kwnames[] = {
22559 (char *) "self", NULL
22560 };
22561
22562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22564 if (SWIG_arg_fail(1)) SWIG_fail;
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22568
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 {
22573 resultobj = wxPyMake_wxObject(result, 0);
22574 }
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22582 PyObject *obj;
22583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22584 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22585 Py_INCREF(obj);
22586 return Py_BuildValue((char *)"");
22587 }
22588 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22589 PyObject *resultobj;
22590 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22591 int arg2 = (int) 0 ;
22592 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22593 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22594 wxContextMenuEvent *result;
22595 wxPoint temp3 ;
22596 PyObject * obj0 = 0 ;
22597 PyObject * obj1 = 0 ;
22598 PyObject * obj2 = 0 ;
22599 char *kwnames[] = {
22600 (char *) "type",(char *) "winid",(char *) "pt", NULL
22601 };
22602
22603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22604 if (obj0) {
22605 {
22606 arg1 = (wxEventType)(SWIG_As_int(obj0));
22607 if (SWIG_arg_fail(1)) SWIG_fail;
22608 }
22609 }
22610 if (obj1) {
22611 {
22612 arg2 = (int)(SWIG_As_int(obj1));
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 }
22615 }
22616 if (obj2) {
22617 {
22618 arg3 = &temp3;
22619 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22620 }
22621 }
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22625
22626 wxPyEndAllowThreads(__tstate);
22627 if (PyErr_Occurred()) SWIG_fail;
22628 }
22629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22637 PyObject *resultobj;
22638 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22639 wxPoint *result;
22640 PyObject * obj0 = 0 ;
22641 char *kwnames[] = {
22642 (char *) "self", NULL
22643 };
22644
22645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22647 if (SWIG_arg_fail(1)) SWIG_fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 {
22651 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22652 result = (wxPoint *) &_result_ref;
22653 }
22654
22655 wxPyEndAllowThreads(__tstate);
22656 if (PyErr_Occurred()) SWIG_fail;
22657 }
22658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22659 return resultobj;
22660 fail:
22661 return NULL;
22662 }
22663
22664
22665 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22666 PyObject *resultobj;
22667 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22668 wxPoint *arg2 = 0 ;
22669 wxPoint temp2 ;
22670 PyObject * obj0 = 0 ;
22671 PyObject * obj1 = 0 ;
22672 char *kwnames[] = {
22673 (char *) "self",(char *) "pos", NULL
22674 };
22675
22676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22678 if (SWIG_arg_fail(1)) SWIG_fail;
22679 {
22680 arg2 = &temp2;
22681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22682 }
22683 {
22684 PyThreadState* __tstate = wxPyBeginAllowThreads();
22685 (arg1)->SetPosition((wxPoint const &)*arg2);
22686
22687 wxPyEndAllowThreads(__tstate);
22688 if (PyErr_Occurred()) SWIG_fail;
22689 }
22690 Py_INCREF(Py_None); resultobj = Py_None;
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22698 PyObject *obj;
22699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22700 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22701 Py_INCREF(obj);
22702 return Py_BuildValue((char *)"");
22703 }
22704 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj;
22706 wxIdleEvent *result;
22707 char *kwnames[] = {
22708 NULL
22709 };
22710
22711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 result = (wxIdleEvent *)new wxIdleEvent();
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22727 PyObject *resultobj;
22728 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22729 bool arg2 = (bool) true ;
22730 PyObject * obj0 = 0 ;
22731 PyObject * obj1 = 0 ;
22732 char *kwnames[] = {
22733 (char *) "self",(char *) "needMore", NULL
22734 };
22735
22736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22738 if (SWIG_arg_fail(1)) SWIG_fail;
22739 if (obj1) {
22740 {
22741 arg2 = (bool)(SWIG_As_bool(obj1));
22742 if (SWIG_arg_fail(2)) SWIG_fail;
22743 }
22744 }
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 (arg1)->RequestMore(arg2);
22748
22749 wxPyEndAllowThreads(__tstate);
22750 if (PyErr_Occurred()) SWIG_fail;
22751 }
22752 Py_INCREF(Py_None); resultobj = Py_None;
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22760 PyObject *resultobj;
22761 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22762 bool result;
22763 PyObject * obj0 = 0 ;
22764 char *kwnames[] = {
22765 (char *) "self", NULL
22766 };
22767
22768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22774
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 {
22779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22780 }
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj;
22789 wxIdleMode arg1 ;
22790 PyObject * obj0 = 0 ;
22791 char *kwnames[] = {
22792 (char *) "mode", NULL
22793 };
22794
22795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22796 {
22797 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22798 if (SWIG_arg_fail(1)) SWIG_fail;
22799 }
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 wxIdleEvent::SetMode((wxIdleMode )arg1);
22803
22804 wxPyEndAllowThreads(__tstate);
22805 if (PyErr_Occurred()) SWIG_fail;
22806 }
22807 Py_INCREF(Py_None); resultobj = Py_None;
22808 return resultobj;
22809 fail:
22810 return NULL;
22811 }
22812
22813
22814 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22815 PyObject *resultobj;
22816 wxIdleMode result;
22817 char *kwnames[] = {
22818 NULL
22819 };
22820
22821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22822 {
22823 PyThreadState* __tstate = wxPyBeginAllowThreads();
22824 result = (wxIdleMode)wxIdleEvent::GetMode();
22825
22826 wxPyEndAllowThreads(__tstate);
22827 if (PyErr_Occurred()) SWIG_fail;
22828 }
22829 resultobj = SWIG_From_int((result));
22830 return resultobj;
22831 fail:
22832 return NULL;
22833 }
22834
22835
22836 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22837 PyObject *resultobj;
22838 wxWindow *arg1 = (wxWindow *) 0 ;
22839 bool result;
22840 PyObject * obj0 = 0 ;
22841 char *kwnames[] = {
22842 (char *) "win", NULL
22843 };
22844
22845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22847 if (SWIG_arg_fail(1)) SWIG_fail;
22848 {
22849 PyThreadState* __tstate = wxPyBeginAllowThreads();
22850 result = (bool)wxIdleEvent::CanSend(arg1);
22851
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 {
22856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22857 }
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22865 PyObject *obj;
22866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22867 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22868 Py_INCREF(obj);
22869 return Py_BuildValue((char *)"");
22870 }
22871 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj;
22873 int arg1 = (int) 0 ;
22874 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22875 wxPyEvent *result;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878 char *kwnames[] = {
22879 (char *) "winid",(char *) "eventType", NULL
22880 };
22881
22882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22883 if (obj0) {
22884 {
22885 arg1 = (int)(SWIG_As_int(obj0));
22886 if (SWIG_arg_fail(1)) SWIG_fail;
22887 }
22888 }
22889 if (obj1) {
22890 {
22891 arg2 = (wxEventType)(SWIG_As_int(obj1));
22892 if (SWIG_arg_fail(2)) SWIG_fail;
22893 }
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22898
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22903 return resultobj;
22904 fail:
22905 return NULL;
22906 }
22907
22908
22909 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22910 PyObject *resultobj;
22911 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22912 PyObject * obj0 = 0 ;
22913 char *kwnames[] = {
22914 (char *) "self", NULL
22915 };
22916
22917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22919 if (SWIG_arg_fail(1)) SWIG_fail;
22920 {
22921 PyThreadState* __tstate = wxPyBeginAllowThreads();
22922 delete arg1;
22923
22924 wxPyEndAllowThreads(__tstate);
22925 if (PyErr_Occurred()) SWIG_fail;
22926 }
22927 Py_INCREF(Py_None); resultobj = Py_None;
22928 return resultobj;
22929 fail:
22930 return NULL;
22931 }
22932
22933
22934 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22935 PyObject *resultobj;
22936 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22937 PyObject *arg2 = (PyObject *) 0 ;
22938 PyObject * obj0 = 0 ;
22939 PyObject * obj1 = 0 ;
22940 char *kwnames[] = {
22941 (char *) "self",(char *) "self", NULL
22942 };
22943
22944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22946 if (SWIG_arg_fail(1)) SWIG_fail;
22947 arg2 = obj1;
22948 {
22949 PyThreadState* __tstate = wxPyBeginAllowThreads();
22950 (arg1)->SetSelf(arg2);
22951
22952 wxPyEndAllowThreads(__tstate);
22953 if (PyErr_Occurred()) SWIG_fail;
22954 }
22955 Py_INCREF(Py_None); resultobj = Py_None;
22956 return resultobj;
22957 fail:
22958 return NULL;
22959 }
22960
22961
22962 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22963 PyObject *resultobj;
22964 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22965 PyObject *result;
22966 PyObject * obj0 = 0 ;
22967 char *kwnames[] = {
22968 (char *) "self", NULL
22969 };
22970
22971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 result = (PyObject *)(arg1)->GetSelf();
22977
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = result;
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22989 PyObject *obj;
22990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22991 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22992 Py_INCREF(obj);
22993 return Py_BuildValue((char *)"");
22994 }
22995 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22996 PyObject *resultobj;
22997 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22998 int arg2 = (int) 0 ;
22999 wxPyCommandEvent *result;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char *kwnames[] = {
23003 (char *) "eventType",(char *) "id", NULL
23004 };
23005
23006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23007 if (obj0) {
23008 {
23009 arg1 = (wxEventType)(SWIG_As_int(obj0));
23010 if (SWIG_arg_fail(1)) SWIG_fail;
23011 }
23012 }
23013 if (obj1) {
23014 {
23015 arg2 = (int)(SWIG_As_int(obj1));
23016 if (SWIG_arg_fail(2)) SWIG_fail;
23017 }
23018 }
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23022
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj;
23035 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23036 PyObject * obj0 = 0 ;
23037 char *kwnames[] = {
23038 (char *) "self", NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23043 if (SWIG_arg_fail(1)) SWIG_fail;
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 delete 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_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23061 PyObject *arg2 = (PyObject *) 0 ;
23062 PyObject * obj0 = 0 ;
23063 PyObject * obj1 = 0 ;
23064 char *kwnames[] = {
23065 (char *) "self",(char *) "self", NULL
23066 };
23067
23068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23070 if (SWIG_arg_fail(1)) SWIG_fail;
23071 arg2 = obj1;
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 (arg1)->SetSelf(arg2);
23075
23076 wxPyEndAllowThreads(__tstate);
23077 if (PyErr_Occurred()) SWIG_fail;
23078 }
23079 Py_INCREF(Py_None); resultobj = Py_None;
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj;
23088 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23089 PyObject *result;
23090 PyObject * obj0 = 0 ;
23091 char *kwnames[] = {
23092 (char *) "self", NULL
23093 };
23094
23095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23097 if (SWIG_arg_fail(1)) SWIG_fail;
23098 {
23099 PyThreadState* __tstate = wxPyBeginAllowThreads();
23100 result = (PyObject *)(arg1)->GetSelf();
23101
23102 wxPyEndAllowThreads(__tstate);
23103 if (PyErr_Occurred()) SWIG_fail;
23104 }
23105 resultobj = result;
23106 return resultobj;
23107 fail:
23108 return NULL;
23109 }
23110
23111
23112 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23113 PyObject *obj;
23114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23115 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23116 Py_INCREF(obj);
23117 return Py_BuildValue((char *)"");
23118 }
23119 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23120 PyObject *resultobj;
23121 wxWindow *arg1 = (wxWindow *) 0 ;
23122 wxDateTime *arg2 = 0 ;
23123 wxEventType arg3 ;
23124 wxDateEvent *result;
23125 PyObject * obj0 = 0 ;
23126 PyObject * obj1 = 0 ;
23127 PyObject * obj2 = 0 ;
23128 char *kwnames[] = {
23129 (char *) "win",(char *) "dt",(char *) "type", NULL
23130 };
23131
23132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23134 if (SWIG_arg_fail(1)) SWIG_fail;
23135 {
23136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23137 if (SWIG_arg_fail(2)) SWIG_fail;
23138 if (arg2 == NULL) {
23139 SWIG_null_ref("wxDateTime");
23140 }
23141 if (SWIG_arg_fail(2)) SWIG_fail;
23142 }
23143 {
23144 arg3 = (wxEventType)(SWIG_As_int(obj2));
23145 if (SWIG_arg_fail(3)) SWIG_fail;
23146 }
23147 {
23148 PyThreadState* __tstate = wxPyBeginAllowThreads();
23149 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23150
23151 wxPyEndAllowThreads(__tstate);
23152 if (PyErr_Occurred()) SWIG_fail;
23153 }
23154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23162 PyObject *resultobj;
23163 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23164 wxDateTime *result;
23165 PyObject * obj0 = 0 ;
23166 char *kwnames[] = {
23167 (char *) "self", NULL
23168 };
23169
23170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23172 if (SWIG_arg_fail(1)) SWIG_fail;
23173 {
23174 PyThreadState* __tstate = wxPyBeginAllowThreads();
23175 {
23176 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23177 result = (wxDateTime *) &_result_ref;
23178 }
23179
23180 wxPyEndAllowThreads(__tstate);
23181 if (PyErr_Occurred()) SWIG_fail;
23182 }
23183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23191 PyObject *resultobj;
23192 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23193 wxDateTime *arg2 = 0 ;
23194 PyObject * obj0 = 0 ;
23195 PyObject * obj1 = 0 ;
23196 char *kwnames[] = {
23197 (char *) "self",(char *) "date", NULL
23198 };
23199
23200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(1)) SWIG_fail;
23203 {
23204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23205 if (SWIG_arg_fail(2)) SWIG_fail;
23206 if (arg2 == NULL) {
23207 SWIG_null_ref("wxDateTime");
23208 }
23209 if (SWIG_arg_fail(2)) SWIG_fail;
23210 }
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 (arg1)->SetDate((wxDateTime const &)*arg2);
23214
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 Py_INCREF(Py_None); resultobj = Py_None;
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23226 PyObject *obj;
23227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23228 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23229 Py_INCREF(obj);
23230 return Py_BuildValue((char *)"");
23231 }
23232 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23233 PyObject *resultobj;
23234 wxPyApp *result;
23235 char *kwnames[] = {
23236 NULL
23237 };
23238
23239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 result = (wxPyApp *)new_wxPyApp();
23243
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj;
23256 wxPyApp *arg1 = (wxPyApp *) 0 ;
23257 PyObject * obj0 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 {
23266 PyThreadState* __tstate = wxPyBeginAllowThreads();
23267 delete arg1;
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_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj;
23281 wxPyApp *arg1 = (wxPyApp *) 0 ;
23282 PyObject *arg2 = (PyObject *) 0 ;
23283 PyObject *arg3 = (PyObject *) 0 ;
23284 bool arg4 ;
23285 PyObject * obj0 = 0 ;
23286 PyObject * obj1 = 0 ;
23287 PyObject * obj2 = 0 ;
23288 PyObject * obj3 = 0 ;
23289 char *kwnames[] = {
23290 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23291 };
23292
23293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23295 if (SWIG_arg_fail(1)) SWIG_fail;
23296 arg2 = obj1;
23297 arg3 = obj2;
23298 {
23299 arg4 = (bool)(SWIG_As_bool(obj3));
23300 if (SWIG_arg_fail(4)) SWIG_fail;
23301 }
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23305
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 Py_INCREF(Py_None); resultobj = Py_None;
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj;
23318 wxPyApp *arg1 = (wxPyApp *) 0 ;
23319 wxString result;
23320 PyObject * obj0 = 0 ;
23321 char *kwnames[] = {
23322 (char *) "self", NULL
23323 };
23324
23325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23327 if (SWIG_arg_fail(1)) SWIG_fail;
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = ((wxPyApp const *)arg1)->GetAppName();
23331
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 {
23336 #if wxUSE_UNICODE
23337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23338 #else
23339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23340 #endif
23341 }
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23349 PyObject *resultobj;
23350 wxPyApp *arg1 = (wxPyApp *) 0 ;
23351 wxString *arg2 = 0 ;
23352 bool temp2 = false ;
23353 PyObject * obj0 = 0 ;
23354 PyObject * obj1 = 0 ;
23355 char *kwnames[] = {
23356 (char *) "self",(char *) "name", NULL
23357 };
23358
23359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23361 if (SWIG_arg_fail(1)) SWIG_fail;
23362 {
23363 arg2 = wxString_in_helper(obj1);
23364 if (arg2 == NULL) SWIG_fail;
23365 temp2 = true;
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 (arg1)->SetAppName((wxString const &)*arg2);
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 Py_INCREF(Py_None); resultobj = Py_None;
23375 {
23376 if (temp2)
23377 delete arg2;
23378 }
23379 return resultobj;
23380 fail:
23381 {
23382 if (temp2)
23383 delete arg2;
23384 }
23385 return NULL;
23386 }
23387
23388
23389 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 wxPyApp *arg1 = (wxPyApp *) 0 ;
23392 wxString result;
23393 PyObject * obj0 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "self", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23400 if (SWIG_arg_fail(1)) SWIG_fail;
23401 {
23402 PyThreadState* __tstate = wxPyBeginAllowThreads();
23403 result = ((wxPyApp const *)arg1)->GetClassName();
23404
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 {
23409 #if wxUSE_UNICODE
23410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23411 #else
23412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23413 #endif
23414 }
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj;
23423 wxPyApp *arg1 = (wxPyApp *) 0 ;
23424 wxString *arg2 = 0 ;
23425 bool temp2 = false ;
23426 PyObject * obj0 = 0 ;
23427 PyObject * obj1 = 0 ;
23428 char *kwnames[] = {
23429 (char *) "self",(char *) "name", NULL
23430 };
23431
23432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23434 if (SWIG_arg_fail(1)) SWIG_fail;
23435 {
23436 arg2 = wxString_in_helper(obj1);
23437 if (arg2 == NULL) SWIG_fail;
23438 temp2 = true;
23439 }
23440 {
23441 PyThreadState* __tstate = wxPyBeginAllowThreads();
23442 (arg1)->SetClassName((wxString const &)*arg2);
23443
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 Py_INCREF(Py_None); resultobj = Py_None;
23448 {
23449 if (temp2)
23450 delete arg2;
23451 }
23452 return resultobj;
23453 fail:
23454 {
23455 if (temp2)
23456 delete arg2;
23457 }
23458 return NULL;
23459 }
23460
23461
23462 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj;
23464 wxPyApp *arg1 = (wxPyApp *) 0 ;
23465 wxString *result;
23466 PyObject * obj0 = 0 ;
23467 char *kwnames[] = {
23468 (char *) "self", NULL
23469 };
23470
23471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23473 if (SWIG_arg_fail(1)) SWIG_fail;
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 {
23477 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23478 result = (wxString *) &_result_ref;
23479 }
23480
23481 wxPyEndAllowThreads(__tstate);
23482 if (PyErr_Occurred()) SWIG_fail;
23483 }
23484 {
23485 #if wxUSE_UNICODE
23486 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23487 #else
23488 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23489 #endif
23490 }
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23498 PyObject *resultobj;
23499 wxPyApp *arg1 = (wxPyApp *) 0 ;
23500 wxString *arg2 = 0 ;
23501 bool temp2 = false ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char *kwnames[] = {
23505 (char *) "self",(char *) "name", NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23510 if (SWIG_arg_fail(1)) SWIG_fail;
23511 {
23512 arg2 = wxString_in_helper(obj1);
23513 if (arg2 == NULL) SWIG_fail;
23514 temp2 = true;
23515 }
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 (arg1)->SetVendorName((wxString const &)*arg2);
23519
23520 wxPyEndAllowThreads(__tstate);
23521 if (PyErr_Occurred()) SWIG_fail;
23522 }
23523 Py_INCREF(Py_None); resultobj = Py_None;
23524 {
23525 if (temp2)
23526 delete arg2;
23527 }
23528 return resultobj;
23529 fail:
23530 {
23531 if (temp2)
23532 delete arg2;
23533 }
23534 return NULL;
23535 }
23536
23537
23538 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23539 PyObject *resultobj;
23540 wxPyApp *arg1 = (wxPyApp *) 0 ;
23541 wxAppTraits *result;
23542 PyObject * obj0 = 0 ;
23543 char *kwnames[] = {
23544 (char *) "self", NULL
23545 };
23546
23547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23549 if (SWIG_arg_fail(1)) SWIG_fail;
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (wxAppTraits *)(arg1)->GetTraits();
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23558 return resultobj;
23559 fail:
23560 return NULL;
23561 }
23562
23563
23564 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23565 PyObject *resultobj;
23566 wxPyApp *arg1 = (wxPyApp *) 0 ;
23567 PyObject * obj0 = 0 ;
23568 char *kwnames[] = {
23569 (char *) "self", NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23574 if (SWIG_arg_fail(1)) SWIG_fail;
23575 {
23576 PyThreadState* __tstate = wxPyBeginAllowThreads();
23577 (arg1)->ProcessPendingEvents();
23578
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 Py_INCREF(Py_None); resultobj = Py_None;
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj;
23591 wxPyApp *arg1 = (wxPyApp *) 0 ;
23592 bool arg2 = (bool) false ;
23593 bool result;
23594 PyObject * obj0 = 0 ;
23595 PyObject * obj1 = 0 ;
23596 char *kwnames[] = {
23597 (char *) "self",(char *) "onlyIfNeeded", NULL
23598 };
23599
23600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23602 if (SWIG_arg_fail(1)) SWIG_fail;
23603 if (obj1) {
23604 {
23605 arg2 = (bool)(SWIG_As_bool(obj1));
23606 if (SWIG_arg_fail(2)) SWIG_fail;
23607 }
23608 }
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = (bool)(arg1)->Yield(arg2);
23612
23613 wxPyEndAllowThreads(__tstate);
23614 if (PyErr_Occurred()) SWIG_fail;
23615 }
23616 {
23617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23618 }
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj;
23627 wxPyApp *arg1 = (wxPyApp *) 0 ;
23628 PyObject * obj0 = 0 ;
23629 char *kwnames[] = {
23630 (char *) "self", NULL
23631 };
23632
23633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23635 if (SWIG_arg_fail(1)) SWIG_fail;
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 (arg1)->WakeUpIdle();
23639
23640 wxPyEndAllowThreads(__tstate);
23641 if (PyErr_Occurred()) SWIG_fail;
23642 }
23643 Py_INCREF(Py_None); resultobj = Py_None;
23644 return resultobj;
23645 fail:
23646 return NULL;
23647 }
23648
23649
23650 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23651 PyObject *resultobj;
23652 bool result;
23653 char *kwnames[] = {
23654 NULL
23655 };
23656
23657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23658 {
23659 PyThreadState* __tstate = wxPyBeginAllowThreads();
23660 result = (bool)wxPyApp::IsMainLoopRunning();
23661
23662 wxPyEndAllowThreads(__tstate);
23663 if (PyErr_Occurred()) SWIG_fail;
23664 }
23665 {
23666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23667 }
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23675 PyObject *resultobj;
23676 wxPyApp *arg1 = (wxPyApp *) 0 ;
23677 int result;
23678 PyObject * obj0 = 0 ;
23679 char *kwnames[] = {
23680 (char *) "self", NULL
23681 };
23682
23683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23685 if (SWIG_arg_fail(1)) SWIG_fail;
23686 {
23687 PyThreadState* __tstate = wxPyBeginAllowThreads();
23688 result = (int)(arg1)->MainLoop();
23689
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 {
23694 resultobj = SWIG_From_int((int)(result));
23695 }
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23703 PyObject *resultobj;
23704 wxPyApp *arg1 = (wxPyApp *) 0 ;
23705 PyObject * obj0 = 0 ;
23706 char *kwnames[] = {
23707 (char *) "self", NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23712 if (SWIG_arg_fail(1)) SWIG_fail;
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 (arg1)->Exit();
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 Py_INCREF(Py_None); resultobj = Py_None;
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj;
23729 wxPyApp *arg1 = (wxPyApp *) 0 ;
23730 PyObject * obj0 = 0 ;
23731 char *kwnames[] = {
23732 (char *) "self", NULL
23733 };
23734
23735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23737 if (SWIG_arg_fail(1)) SWIG_fail;
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 (arg1)->ExitMainLoop();
23741
23742 wxPyEndAllowThreads(__tstate);
23743 if (PyErr_Occurred()) SWIG_fail;
23744 }
23745 Py_INCREF(Py_None); resultobj = Py_None;
23746 return resultobj;
23747 fail:
23748 return NULL;
23749 }
23750
23751
23752 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj;
23754 wxPyApp *arg1 = (wxPyApp *) 0 ;
23755 bool result;
23756 PyObject * obj0 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (bool)(arg1)->Pending();
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 {
23772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23773 }
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23781 PyObject *resultobj;
23782 wxPyApp *arg1 = (wxPyApp *) 0 ;
23783 bool result;
23784 PyObject * obj0 = 0 ;
23785 char *kwnames[] = {
23786 (char *) "self", NULL
23787 };
23788
23789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23791 if (SWIG_arg_fail(1)) SWIG_fail;
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = (bool)(arg1)->Dispatch();
23795
23796 wxPyEndAllowThreads(__tstate);
23797 if (PyErr_Occurred()) SWIG_fail;
23798 }
23799 {
23800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23801 }
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23809 PyObject *resultobj;
23810 wxPyApp *arg1 = (wxPyApp *) 0 ;
23811 bool result;
23812 PyObject * obj0 = 0 ;
23813 char *kwnames[] = {
23814 (char *) "self", NULL
23815 };
23816
23817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23819 if (SWIG_arg_fail(1)) SWIG_fail;
23820 {
23821 PyThreadState* __tstate = wxPyBeginAllowThreads();
23822 result = (bool)(arg1)->ProcessIdle();
23823
23824 wxPyEndAllowThreads(__tstate);
23825 if (PyErr_Occurred()) SWIG_fail;
23826 }
23827 {
23828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23829 }
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 wxPyApp *arg1 = (wxPyApp *) 0 ;
23839 wxWindow *arg2 = (wxWindow *) 0 ;
23840 wxIdleEvent *arg3 = 0 ;
23841 bool result;
23842 PyObject * obj0 = 0 ;
23843 PyObject * obj1 = 0 ;
23844 PyObject * obj2 = 0 ;
23845 char *kwnames[] = {
23846 (char *) "self",(char *) "win",(char *) "event", NULL
23847 };
23848
23849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23851 if (SWIG_arg_fail(1)) SWIG_fail;
23852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23853 if (SWIG_arg_fail(2)) SWIG_fail;
23854 {
23855 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23856 if (SWIG_arg_fail(3)) SWIG_fail;
23857 if (arg3 == NULL) {
23858 SWIG_null_ref("wxIdleEvent");
23859 }
23860 if (SWIG_arg_fail(3)) SWIG_fail;
23861 }
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23865
23866 wxPyEndAllowThreads(__tstate);
23867 if (PyErr_Occurred()) SWIG_fail;
23868 }
23869 {
23870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23871 }
23872 return resultobj;
23873 fail:
23874 return NULL;
23875 }
23876
23877
23878 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23879 PyObject *resultobj;
23880 wxPyApp *arg1 = (wxPyApp *) 0 ;
23881 bool result;
23882 PyObject * obj0 = 0 ;
23883 char *kwnames[] = {
23884 (char *) "self", NULL
23885 };
23886
23887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23889 if (SWIG_arg_fail(1)) SWIG_fail;
23890 {
23891 PyThreadState* __tstate = wxPyBeginAllowThreads();
23892 result = (bool)((wxPyApp const *)arg1)->IsActive();
23893
23894 wxPyEndAllowThreads(__tstate);
23895 if (PyErr_Occurred()) SWIG_fail;
23896 }
23897 {
23898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23899 }
23900 return resultobj;
23901 fail:
23902 return NULL;
23903 }
23904
23905
23906 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23907 PyObject *resultobj;
23908 wxPyApp *arg1 = (wxPyApp *) 0 ;
23909 wxWindow *arg2 = (wxWindow *) 0 ;
23910 PyObject * obj0 = 0 ;
23911 PyObject * obj1 = 0 ;
23912 char *kwnames[] = {
23913 (char *) "self",(char *) "win", NULL
23914 };
23915
23916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23918 if (SWIG_arg_fail(1)) SWIG_fail;
23919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23920 if (SWIG_arg_fail(2)) SWIG_fail;
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 (arg1)->SetTopWindow(arg2);
23924
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 Py_INCREF(Py_None); resultobj = Py_None;
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj;
23937 wxPyApp *arg1 = (wxPyApp *) 0 ;
23938 wxWindow *result;
23939 PyObject * obj0 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 resultobj = wxPyMake_wxObject(result, 0);
23956 }
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj;
23965 wxPyApp *arg1 = (wxPyApp *) 0 ;
23966 bool arg2 ;
23967 PyObject * obj0 = 0 ;
23968 PyObject * obj1 = 0 ;
23969 char *kwnames[] = {
23970 (char *) "self",(char *) "flag", NULL
23971 };
23972
23973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23975 if (SWIG_arg_fail(1)) SWIG_fail;
23976 {
23977 arg2 = (bool)(SWIG_As_bool(obj1));
23978 if (SWIG_arg_fail(2)) SWIG_fail;
23979 }
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 (arg1)->SetExitOnFrameDelete(arg2);
23983
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 Py_INCREF(Py_None); resultobj = Py_None;
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23995 PyObject *resultobj;
23996 wxPyApp *arg1 = (wxPyApp *) 0 ;
23997 bool result;
23998 PyObject * obj0 = 0 ;
23999 char *kwnames[] = {
24000 (char *) "self", NULL
24001 };
24002
24003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24005 if (SWIG_arg_fail(1)) SWIG_fail;
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 wxPyApp *arg1 = (wxPyApp *) 0 ;
24025 bool arg2 ;
24026 PyObject * obj0 = 0 ;
24027 PyObject * obj1 = 0 ;
24028 char *kwnames[] = {
24029 (char *) "self",(char *) "flag", NULL
24030 };
24031
24032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24034 if (SWIG_arg_fail(1)) SWIG_fail;
24035 {
24036 arg2 = (bool)(SWIG_As_bool(obj1));
24037 if (SWIG_arg_fail(2)) SWIG_fail;
24038 }
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 (arg1)->SetUseBestVisual(arg2);
24042
24043 wxPyEndAllowThreads(__tstate);
24044 if (PyErr_Occurred()) SWIG_fail;
24045 }
24046 Py_INCREF(Py_None); resultobj = Py_None;
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24054 PyObject *resultobj;
24055 wxPyApp *arg1 = (wxPyApp *) 0 ;
24056 bool result;
24057 PyObject * obj0 = 0 ;
24058 char *kwnames[] = {
24059 (char *) "self", NULL
24060 };
24061
24062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24064 if (SWIG_arg_fail(1)) SWIG_fail;
24065 {
24066 PyThreadState* __tstate = wxPyBeginAllowThreads();
24067 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24068
24069 wxPyEndAllowThreads(__tstate);
24070 if (PyErr_Occurred()) SWIG_fail;
24071 }
24072 {
24073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24074 }
24075 return resultobj;
24076 fail:
24077 return NULL;
24078 }
24079
24080
24081 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24082 PyObject *resultobj;
24083 wxPyApp *arg1 = (wxPyApp *) 0 ;
24084 int arg2 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 char *kwnames[] = {
24088 (char *) "self",(char *) "mode", NULL
24089 };
24090
24091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24093 if (SWIG_arg_fail(1)) SWIG_fail;
24094 {
24095 arg2 = (int)(SWIG_As_int(obj1));
24096 if (SWIG_arg_fail(2)) SWIG_fail;
24097 }
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 (arg1)->SetPrintMode(arg2);
24101
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 Py_INCREF(Py_None); resultobj = Py_None;
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj;
24114 wxPyApp *arg1 = (wxPyApp *) 0 ;
24115 int result;
24116 PyObject * obj0 = 0 ;
24117 char *kwnames[] = {
24118 (char *) "self", NULL
24119 };
24120
24121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24123 if (SWIG_arg_fail(1)) SWIG_fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 {
24132 resultobj = SWIG_From_int((int)(result));
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 wxPyApp *arg1 = (wxPyApp *) 0 ;
24143 int arg2 ;
24144 PyObject * obj0 = 0 ;
24145 PyObject * obj1 = 0 ;
24146 char *kwnames[] = {
24147 (char *) "self",(char *) "mode", NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24152 if (SWIG_arg_fail(1)) SWIG_fail;
24153 {
24154 arg2 = (int)(SWIG_As_int(obj1));
24155 if (SWIG_arg_fail(2)) SWIG_fail;
24156 }
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 (arg1)->SetAssertMode(arg2);
24160
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 Py_INCREF(Py_None); resultobj = Py_None;
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj;
24173 wxPyApp *arg1 = (wxPyApp *) 0 ;
24174 int result;
24175 PyObject * obj0 = 0 ;
24176 char *kwnames[] = {
24177 (char *) "self", NULL
24178 };
24179
24180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24182 if (SWIG_arg_fail(1)) SWIG_fail;
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = (int)(arg1)->GetAssertMode();
24186
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 {
24191 resultobj = SWIG_From_int((int)(result));
24192 }
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24200 PyObject *resultobj;
24201 bool result;
24202 char *kwnames[] = {
24203 NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24210
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 {
24215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24216 }
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 long result;
24226 char *kwnames[] = {
24227 NULL
24228 };
24229
24230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (long)wxPyApp::GetMacAboutMenuItemId();
24234
24235 wxPyEndAllowThreads(__tstate);
24236 if (PyErr_Occurred()) SWIG_fail;
24237 }
24238 {
24239 resultobj = SWIG_From_long((long)(result));
24240 }
24241 return resultobj;
24242 fail:
24243 return NULL;
24244 }
24245
24246
24247 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24248 PyObject *resultobj;
24249 long result;
24250 char *kwnames[] = {
24251 NULL
24252 };
24253
24254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24258
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 {
24263 resultobj = SWIG_From_long((long)(result));
24264 }
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24272 PyObject *resultobj;
24273 long result;
24274 char *kwnames[] = {
24275 NULL
24276 };
24277
24278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (long)wxPyApp::GetMacExitMenuItemId();
24282
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 {
24287 resultobj = SWIG_From_long((long)(result));
24288 }
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj;
24297 wxString result;
24298 char *kwnames[] = {
24299 NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24303 {
24304 PyThreadState* __tstate = wxPyBeginAllowThreads();
24305 result = wxPyApp::GetMacHelpMenuTitleName();
24306
24307 wxPyEndAllowThreads(__tstate);
24308 if (PyErr_Occurred()) SWIG_fail;
24309 }
24310 {
24311 #if wxUSE_UNICODE
24312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24313 #else
24314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24315 #endif
24316 }
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24324 PyObject *resultobj;
24325 bool arg1 ;
24326 PyObject * obj0 = 0 ;
24327 char *kwnames[] = {
24328 (char *) "val", NULL
24329 };
24330
24331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24332 {
24333 arg1 = (bool)(SWIG_As_bool(obj0));
24334 if (SWIG_arg_fail(1)) SWIG_fail;
24335 }
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 Py_INCREF(Py_None); resultobj = Py_None;
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 long arg1 ;
24353 PyObject * obj0 = 0 ;
24354 char *kwnames[] = {
24355 (char *) "val", NULL
24356 };
24357
24358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24359 {
24360 arg1 = (long)(SWIG_As_long(obj0));
24361 if (SWIG_arg_fail(1)) SWIG_fail;
24362 }
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 wxPyApp::SetMacAboutMenuItemId(arg1);
24366
24367 wxPyEndAllowThreads(__tstate);
24368 if (PyErr_Occurred()) SWIG_fail;
24369 }
24370 Py_INCREF(Py_None); resultobj = Py_None;
24371 return resultobj;
24372 fail:
24373 return NULL;
24374 }
24375
24376
24377 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24378 PyObject *resultobj;
24379 long arg1 ;
24380 PyObject * obj0 = 0 ;
24381 char *kwnames[] = {
24382 (char *) "val", NULL
24383 };
24384
24385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24386 {
24387 arg1 = (long)(SWIG_As_long(obj0));
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 }
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24393
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 Py_INCREF(Py_None); resultobj = Py_None;
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24405 PyObject *resultobj;
24406 long arg1 ;
24407 PyObject * obj0 = 0 ;
24408 char *kwnames[] = {
24409 (char *) "val", NULL
24410 };
24411
24412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24413 {
24414 arg1 = (long)(SWIG_As_long(obj0));
24415 if (SWIG_arg_fail(1)) SWIG_fail;
24416 }
24417 {
24418 PyThreadState* __tstate = wxPyBeginAllowThreads();
24419 wxPyApp::SetMacExitMenuItemId(arg1);
24420
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 Py_INCREF(Py_None); resultobj = Py_None;
24425 return resultobj;
24426 fail:
24427 return NULL;
24428 }
24429
24430
24431 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24432 PyObject *resultobj;
24433 wxString *arg1 = 0 ;
24434 bool temp1 = false ;
24435 PyObject * obj0 = 0 ;
24436 char *kwnames[] = {
24437 (char *) "val", NULL
24438 };
24439
24440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24441 {
24442 arg1 = wxString_in_helper(obj0);
24443 if (arg1 == NULL) SWIG_fail;
24444 temp1 = true;
24445 }
24446 {
24447 PyThreadState* __tstate = wxPyBeginAllowThreads();
24448 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24449
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 Py_INCREF(Py_None); resultobj = Py_None;
24454 {
24455 if (temp1)
24456 delete arg1;
24457 }
24458 return resultobj;
24459 fail:
24460 {
24461 if (temp1)
24462 delete arg1;
24463 }
24464 return NULL;
24465 }
24466
24467
24468 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24469 PyObject *resultobj;
24470 wxPyApp *arg1 = (wxPyApp *) 0 ;
24471 PyObject * obj0 = 0 ;
24472 char *kwnames[] = {
24473 (char *) "self", NULL
24474 };
24475
24476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24478 if (SWIG_arg_fail(1)) SWIG_fail;
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 (arg1)->_BootstrapApp();
24482
24483 wxPyEndAllowThreads(__tstate);
24484 if (PyErr_Occurred()) SWIG_fail;
24485 }
24486 Py_INCREF(Py_None); resultobj = Py_None;
24487 return resultobj;
24488 fail:
24489 return NULL;
24490 }
24491
24492
24493 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24494 PyObject *resultobj;
24495 int result;
24496 char *kwnames[] = {
24497 NULL
24498 };
24499
24500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24501 {
24502 PyThreadState* __tstate = wxPyBeginAllowThreads();
24503 result = (int)PyApp_GetComCtl32Version();
24504
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 {
24509 resultobj = SWIG_From_int((int)(result));
24510 }
24511 return resultobj;
24512 fail:
24513 return NULL;
24514 }
24515
24516
24517 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24518 PyObject *obj;
24519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24520 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24521 Py_INCREF(obj);
24522 return Py_BuildValue((char *)"");
24523 }
24524 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24525 PyObject *resultobj;
24526 char *kwnames[] = {
24527 NULL
24528 };
24529
24530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 wxExit();
24534
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 Py_INCREF(Py_None); resultobj = Py_None;
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24546 PyObject *resultobj;
24547 bool result;
24548 char *kwnames[] = {
24549 NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 result = (bool)wxYield();
24556
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 {
24561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24562 }
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj;
24571 bool result;
24572 char *kwnames[] = {
24573 NULL
24574 };
24575
24576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24577 {
24578 PyThreadState* __tstate = wxPyBeginAllowThreads();
24579 result = (bool)wxYieldIfNeeded();
24580
24581 wxPyEndAllowThreads(__tstate);
24582 if (PyErr_Occurred()) SWIG_fail;
24583 }
24584 {
24585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24586 }
24587 return resultobj;
24588 fail:
24589 return NULL;
24590 }
24591
24592
24593 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24594 PyObject *resultobj;
24595 wxWindow *arg1 = (wxWindow *) NULL ;
24596 bool arg2 = (bool) false ;
24597 bool result;
24598 PyObject * obj0 = 0 ;
24599 PyObject * obj1 = 0 ;
24600 char *kwnames[] = {
24601 (char *) "win",(char *) "onlyIfNeeded", NULL
24602 };
24603
24604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24605 if (obj0) {
24606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24607 if (SWIG_arg_fail(1)) SWIG_fail;
24608 }
24609 if (obj1) {
24610 {
24611 arg2 = (bool)(SWIG_As_bool(obj1));
24612 if (SWIG_arg_fail(2)) SWIG_fail;
24613 }
24614 }
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (bool)wxSafeYield(arg1,arg2);
24618
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 {
24623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24624 }
24625 return resultobj;
24626 fail:
24627 return NULL;
24628 }
24629
24630
24631 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24632 PyObject *resultobj;
24633 char *kwnames[] = {
24634 NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 wxWakeUpIdle();
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 Py_INCREF(Py_None); resultobj = Py_None;
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24655 wxEvent *arg2 = 0 ;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 char *kwnames[] = {
24659 (char *) "dest",(char *) "event", NULL
24660 };
24661
24662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24664 if (SWIG_arg_fail(1)) SWIG_fail;
24665 {
24666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24667 if (SWIG_arg_fail(2)) SWIG_fail;
24668 if (arg2 == NULL) {
24669 SWIG_null_ref("wxEvent");
24670 }
24671 if (SWIG_arg_fail(2)) SWIG_fail;
24672 }
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 wxPostEvent(arg1,*arg2);
24676
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 Py_INCREF(Py_None); resultobj = Py_None;
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj;
24689 char *kwnames[] = {
24690 NULL
24691 };
24692
24693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 wxApp_CleanUp();
24697
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 Py_INCREF(Py_None); resultobj = Py_None;
24702 return resultobj;
24703 fail:
24704 return NULL;
24705 }
24706
24707
24708 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24709 PyObject *resultobj;
24710 wxPyApp *result;
24711 char *kwnames[] = {
24712 NULL
24713 };
24714
24715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (wxPyApp *)wxPyGetApp();
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 {
24724 resultobj = wxPyMake_wxObject(result, 0);
24725 }
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 char *arg1 = (char *) 0 ;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "encoding", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24741 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24742 SWIG_arg_fail(1);SWIG_fail;
24743 }
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 wxSetDefaultPyEncoding((char const *)arg1);
24747
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 Py_INCREF(Py_None); resultobj = Py_None;
24752 return resultobj;
24753 fail:
24754 return NULL;
24755 }
24756
24757
24758 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24759 PyObject *resultobj;
24760 char *result;
24761 char *kwnames[] = {
24762 NULL
24763 };
24764
24765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24766 {
24767 PyThreadState* __tstate = wxPyBeginAllowThreads();
24768 result = (char *)wxGetDefaultPyEncoding();
24769
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 resultobj = SWIG_FromCharPtr(result);
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24781 PyObject *resultobj;
24782 wxEventLoop *result;
24783 char *kwnames[] = {
24784 NULL
24785 };
24786
24787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 result = (wxEventLoop *)new wxEventLoop();
24791
24792 wxPyEndAllowThreads(__tstate);
24793 if (PyErr_Occurred()) SWIG_fail;
24794 }
24795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24803 PyObject *resultobj;
24804 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24805 PyObject * obj0 = 0 ;
24806 char *kwnames[] = {
24807 (char *) "self", NULL
24808 };
24809
24810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24812 if (SWIG_arg_fail(1)) SWIG_fail;
24813 {
24814 PyThreadState* __tstate = wxPyBeginAllowThreads();
24815 delete arg1;
24816
24817 wxPyEndAllowThreads(__tstate);
24818 if (PyErr_Occurred()) SWIG_fail;
24819 }
24820 Py_INCREF(Py_None); resultobj = Py_None;
24821 return resultobj;
24822 fail:
24823 return NULL;
24824 }
24825
24826
24827 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24828 PyObject *resultobj;
24829 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24830 int result;
24831 PyObject * obj0 = 0 ;
24832 char *kwnames[] = {
24833 (char *) "self", NULL
24834 };
24835
24836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24838 if (SWIG_arg_fail(1)) SWIG_fail;
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 result = (int)(arg1)->Run();
24842
24843 wxPyEndAllowThreads(__tstate);
24844 if (PyErr_Occurred()) SWIG_fail;
24845 }
24846 {
24847 resultobj = SWIG_From_int((int)(result));
24848 }
24849 return resultobj;
24850 fail:
24851 return NULL;
24852 }
24853
24854
24855 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24856 PyObject *resultobj;
24857 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24858 int arg2 = (int) 0 ;
24859 PyObject * obj0 = 0 ;
24860 PyObject * obj1 = 0 ;
24861 char *kwnames[] = {
24862 (char *) "self",(char *) "rc", NULL
24863 };
24864
24865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24867 if (SWIG_arg_fail(1)) SWIG_fail;
24868 if (obj1) {
24869 {
24870 arg2 = (int)(SWIG_As_int(obj1));
24871 if (SWIG_arg_fail(2)) SWIG_fail;
24872 }
24873 }
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 (arg1)->Exit(arg2);
24877
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 Py_INCREF(Py_None); resultobj = Py_None;
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24891 bool result;
24892 PyObject * obj0 = 0 ;
24893 char *kwnames[] = {
24894 (char *) "self", NULL
24895 };
24896
24897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24899 if (SWIG_arg_fail(1)) SWIG_fail;
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (bool)((wxEventLoop const *)arg1)->Pending();
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24919 bool result;
24920 PyObject * obj0 = 0 ;
24921 char *kwnames[] = {
24922 (char *) "self", NULL
24923 };
24924
24925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24927 if (SWIG_arg_fail(1)) SWIG_fail;
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (bool)(arg1)->Dispatch();
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24947 bool result;
24948 PyObject * obj0 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24959
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 {
24964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24965 }
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxEventLoop *result;
24975 char *kwnames[] = {
24976 NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 result = (wxEventLoop *)wxEventLoop::GetActive();
24983
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj;
24996 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24997 PyObject * obj0 = 0 ;
24998 char *kwnames[] = {
24999 (char *) "loop", NULL
25000 };
25001
25002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25004 if (SWIG_arg_fail(1)) SWIG_fail;
25005 {
25006 PyThreadState* __tstate = wxPyBeginAllowThreads();
25007 wxEventLoop::SetActive(arg1);
25008
25009 wxPyEndAllowThreads(__tstate);
25010 if (PyErr_Occurred()) SWIG_fail;
25011 }
25012 Py_INCREF(Py_None); resultobj = Py_None;
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25020 PyObject *obj;
25021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25022 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25023 Py_INCREF(obj);
25024 return Py_BuildValue((char *)"");
25025 }
25026 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25027 PyObject *resultobj;
25028 int arg1 = (int) 0 ;
25029 int arg2 = (int) 0 ;
25030 int arg3 = (int) 0 ;
25031 wxAcceleratorEntry *result;
25032 PyObject * obj0 = 0 ;
25033 PyObject * obj1 = 0 ;
25034 PyObject * obj2 = 0 ;
25035 char *kwnames[] = {
25036 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25037 };
25038
25039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25040 if (obj0) {
25041 {
25042 arg1 = (int)(SWIG_As_int(obj0));
25043 if (SWIG_arg_fail(1)) SWIG_fail;
25044 }
25045 }
25046 if (obj1) {
25047 {
25048 arg2 = (int)(SWIG_As_int(obj1));
25049 if (SWIG_arg_fail(2)) SWIG_fail;
25050 }
25051 }
25052 if (obj2) {
25053 {
25054 arg3 = (int)(SWIG_As_int(obj2));
25055 if (SWIG_arg_fail(3)) SWIG_fail;
25056 }
25057 }
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25061
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25073 PyObject *resultobj;
25074 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25075 PyObject * obj0 = 0 ;
25076 char *kwnames[] = {
25077 (char *) "self", NULL
25078 };
25079
25080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25082 if (SWIG_arg_fail(1)) SWIG_fail;
25083 {
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 delete arg1;
25086
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 Py_INCREF(Py_None); resultobj = Py_None;
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj;
25099 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25100 int arg2 ;
25101 int arg3 ;
25102 int arg4 ;
25103 PyObject * obj0 = 0 ;
25104 PyObject * obj1 = 0 ;
25105 PyObject * obj2 = 0 ;
25106 PyObject * obj3 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 {
25115 arg2 = (int)(SWIG_As_int(obj1));
25116 if (SWIG_arg_fail(2)) SWIG_fail;
25117 }
25118 {
25119 arg3 = (int)(SWIG_As_int(obj2));
25120 if (SWIG_arg_fail(3)) SWIG_fail;
25121 }
25122 {
25123 arg4 = (int)(SWIG_As_int(obj3));
25124 if (SWIG_arg_fail(4)) SWIG_fail;
25125 }
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 (arg1)->Set(arg2,arg3,arg4);
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 Py_INCREF(Py_None); resultobj = Py_None;
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj;
25142 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25143 int result;
25144 PyObject * obj0 = 0 ;
25145 char *kwnames[] = {
25146 (char *) "self", NULL
25147 };
25148
25149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25151 if (SWIG_arg_fail(1)) SWIG_fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (int)(arg1)->GetFlags();
25155
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = SWIG_From_int((int)(result));
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj;
25170 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25171 int result;
25172 PyObject * obj0 = 0 ;
25173 char *kwnames[] = {
25174 (char *) "self", NULL
25175 };
25176
25177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25179 if (SWIG_arg_fail(1)) SWIG_fail;
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (int)(arg1)->GetKeyCode();
25183
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 {
25188 resultobj = SWIG_From_int((int)(result));
25189 }
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj;
25198 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25199 int result;
25200 PyObject * obj0 = 0 ;
25201 char *kwnames[] = {
25202 (char *) "self", NULL
25203 };
25204
25205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (int)(arg1)->GetCommand();
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = SWIG_From_int((int)(result));
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25225 PyObject *obj;
25226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25227 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25228 Py_INCREF(obj);
25229 return Py_BuildValue((char *)"");
25230 }
25231 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25232 PyObject *resultobj;
25233 int arg1 ;
25234 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25235 wxAcceleratorTable *result;
25236 PyObject * obj0 = 0 ;
25237 char *kwnames[] = {
25238 (char *) "n", NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25242 {
25243 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25244 if (arg2) arg1 = PyList_Size(obj0);
25245 else arg1 = 0;
25246 }
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25250
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25255 {
25256 delete [] arg2;
25257 }
25258 return resultobj;
25259 fail:
25260 {
25261 delete [] arg2;
25262 }
25263 return NULL;
25264 }
25265
25266
25267 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj;
25269 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25270 PyObject * obj0 = 0 ;
25271 char *kwnames[] = {
25272 (char *) "self", NULL
25273 };
25274
25275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25277 if (SWIG_arg_fail(1)) SWIG_fail;
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 delete arg1;
25281
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 Py_INCREF(Py_None); resultobj = Py_None;
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25293 PyObject *resultobj;
25294 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25295 bool result;
25296 PyObject * obj0 = 0 ;
25297 char *kwnames[] = {
25298 (char *) "self", NULL
25299 };
25300
25301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25303 if (SWIG_arg_fail(1)) SWIG_fail;
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25307
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 {
25312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25313 }
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25321 PyObject *obj;
25322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25323 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25324 Py_INCREF(obj);
25325 return Py_BuildValue((char *)"");
25326 }
25327 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25328 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25329 return 1;
25330 }
25331
25332
25333 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25334 PyObject *pyobj;
25335
25336 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25337 return pyobj;
25338 }
25339
25340
25341 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25342 PyObject *resultobj;
25343 wxString *arg1 = 0 ;
25344 wxAcceleratorEntry *result;
25345 bool temp1 = false ;
25346 PyObject * obj0 = 0 ;
25347 char *kwnames[] = {
25348 (char *) "label", NULL
25349 };
25350
25351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25352 {
25353 arg1 = wxString_in_helper(obj0);
25354 if (arg1 == NULL) SWIG_fail;
25355 temp1 = true;
25356 }
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25360
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25365 {
25366 if (temp1)
25367 delete arg1;
25368 }
25369 return resultobj;
25370 fail:
25371 {
25372 if (temp1)
25373 delete arg1;
25374 }
25375 return NULL;
25376 }
25377
25378
25379 static int _wrap_PanelNameStr_set(PyObject *) {
25380 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25381 return 1;
25382 }
25383
25384
25385 static PyObject *_wrap_PanelNameStr_get(void) {
25386 PyObject *pyobj;
25387
25388 {
25389 #if wxUSE_UNICODE
25390 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25391 #else
25392 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25393 #endif
25394 }
25395 return pyobj;
25396 }
25397
25398
25399 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj;
25401 wxVisualAttributes *result;
25402 char *kwnames[] = {
25403 NULL
25404 };
25405
25406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = (wxVisualAttributes *)new_wxVisualAttributes();
25410
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj;
25423 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25424 PyObject * obj0 = 0 ;
25425 char *kwnames[] = {
25426 (char *) "self", NULL
25427 };
25428
25429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25431 if (SWIG_arg_fail(1)) SWIG_fail;
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 delete_wxVisualAttributes(arg1);
25435
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 Py_INCREF(Py_None); resultobj = Py_None;
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj;
25448 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25449 wxFont *arg2 = (wxFont *) 0 ;
25450 PyObject * obj0 = 0 ;
25451 PyObject * obj1 = 0 ;
25452 char *kwnames[] = {
25453 (char *) "self",(char *) "font", NULL
25454 };
25455
25456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25458 if (SWIG_arg_fail(1)) SWIG_fail;
25459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25460 if (SWIG_arg_fail(2)) SWIG_fail;
25461 if (arg1) (arg1)->font = *arg2;
25462
25463 Py_INCREF(Py_None); resultobj = Py_None;
25464 return resultobj;
25465 fail:
25466 return NULL;
25467 }
25468
25469
25470 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj;
25472 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25473 wxFont *result;
25474 PyObject * obj0 = 0 ;
25475 char *kwnames[] = {
25476 (char *) "self", NULL
25477 };
25478
25479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25481 if (SWIG_arg_fail(1)) SWIG_fail;
25482 result = (wxFont *)& ((arg1)->font);
25483
25484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25494 wxColour *arg2 = (wxColour *) 0 ;
25495 PyObject * obj0 = 0 ;
25496 PyObject * obj1 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "self",(char *) "colFg", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25503 if (SWIG_arg_fail(1)) SWIG_fail;
25504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25505 if (SWIG_arg_fail(2)) SWIG_fail;
25506 if (arg1) (arg1)->colFg = *arg2;
25507
25508 Py_INCREF(Py_None); resultobj = Py_None;
25509 return resultobj;
25510 fail:
25511 return NULL;
25512 }
25513
25514
25515 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25516 PyObject *resultobj;
25517 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25518 wxColour *result;
25519 PyObject * obj0 = 0 ;
25520 char *kwnames[] = {
25521 (char *) "self", NULL
25522 };
25523
25524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25526 if (SWIG_arg_fail(1)) SWIG_fail;
25527 result = (wxColour *)& ((arg1)->colFg);
25528
25529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25537 PyObject *resultobj;
25538 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25539 wxColour *arg2 = (wxColour *) 0 ;
25540 PyObject * obj0 = 0 ;
25541 PyObject * obj1 = 0 ;
25542 char *kwnames[] = {
25543 (char *) "self",(char *) "colBg", NULL
25544 };
25545
25546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25548 if (SWIG_arg_fail(1)) SWIG_fail;
25549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(2)) SWIG_fail;
25551 if (arg1) (arg1)->colBg = *arg2;
25552
25553 Py_INCREF(Py_None); resultobj = Py_None;
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25561 PyObject *resultobj;
25562 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25563 wxColour *result;
25564 PyObject * obj0 = 0 ;
25565 char *kwnames[] = {
25566 (char *) "self", NULL
25567 };
25568
25569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25571 if (SWIG_arg_fail(1)) SWIG_fail;
25572 result = (wxColour *)& ((arg1)->colBg);
25573
25574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25582 PyObject *obj;
25583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25584 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25585 Py_INCREF(obj);
25586 return Py_BuildValue((char *)"");
25587 }
25588 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25589 PyObject *resultobj;
25590 wxWindow *arg1 = (wxWindow *) 0 ;
25591 int arg2 = (int) (int)-1 ;
25592 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25593 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25594 wxSize const &arg4_defvalue = wxDefaultSize ;
25595 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25596 long arg5 = (long) 0 ;
25597 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25598 wxString *arg6 = (wxString *) &arg6_defvalue ;
25599 wxWindow *result;
25600 wxPoint temp3 ;
25601 wxSize temp4 ;
25602 bool temp6 = false ;
25603 PyObject * obj0 = 0 ;
25604 PyObject * obj1 = 0 ;
25605 PyObject * obj2 = 0 ;
25606 PyObject * obj3 = 0 ;
25607 PyObject * obj4 = 0 ;
25608 PyObject * obj5 = 0 ;
25609 char *kwnames[] = {
25610 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25611 };
25612
25613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25615 if (SWIG_arg_fail(1)) SWIG_fail;
25616 if (obj1) {
25617 {
25618 arg2 = (int const)(SWIG_As_int(obj1));
25619 if (SWIG_arg_fail(2)) SWIG_fail;
25620 }
25621 }
25622 if (obj2) {
25623 {
25624 arg3 = &temp3;
25625 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25626 }
25627 }
25628 if (obj3) {
25629 {
25630 arg4 = &temp4;
25631 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25632 }
25633 }
25634 if (obj4) {
25635 {
25636 arg5 = (long)(SWIG_As_long(obj4));
25637 if (SWIG_arg_fail(5)) SWIG_fail;
25638 }
25639 }
25640 if (obj5) {
25641 {
25642 arg6 = wxString_in_helper(obj5);
25643 if (arg6 == NULL) SWIG_fail;
25644 temp6 = true;
25645 }
25646 }
25647 {
25648 if (!wxPyCheckForApp()) SWIG_fail;
25649 PyThreadState* __tstate = wxPyBeginAllowThreads();
25650 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25651
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25656 {
25657 if (temp6)
25658 delete arg6;
25659 }
25660 return resultobj;
25661 fail:
25662 {
25663 if (temp6)
25664 delete arg6;
25665 }
25666 return NULL;
25667 }
25668
25669
25670 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25671 PyObject *resultobj;
25672 wxWindow *result;
25673 char *kwnames[] = {
25674 NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25678 {
25679 if (!wxPyCheckForApp()) SWIG_fail;
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 result = (wxWindow *)new wxWindow();
25682
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25694 PyObject *resultobj;
25695 wxWindow *arg1 = (wxWindow *) 0 ;
25696 wxWindow *arg2 = (wxWindow *) 0 ;
25697 int arg3 = (int) (int)-1 ;
25698 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25699 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25700 wxSize const &arg5_defvalue = wxDefaultSize ;
25701 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25702 long arg6 = (long) 0 ;
25703 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25704 wxString *arg7 = (wxString *) &arg7_defvalue ;
25705 bool result;
25706 wxPoint temp4 ;
25707 wxSize temp5 ;
25708 bool temp7 = false ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 PyObject * obj2 = 0 ;
25712 PyObject * obj3 = 0 ;
25713 PyObject * obj4 = 0 ;
25714 PyObject * obj5 = 0 ;
25715 PyObject * obj6 = 0 ;
25716 char *kwnames[] = {
25717 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25718 };
25719
25720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(2)) SWIG_fail;
25725 if (obj2) {
25726 {
25727 arg3 = (int const)(SWIG_As_int(obj2));
25728 if (SWIG_arg_fail(3)) SWIG_fail;
25729 }
25730 }
25731 if (obj3) {
25732 {
25733 arg4 = &temp4;
25734 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25735 }
25736 }
25737 if (obj4) {
25738 {
25739 arg5 = &temp5;
25740 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25741 }
25742 }
25743 if (obj5) {
25744 {
25745 arg6 = (long)(SWIG_As_long(obj5));
25746 if (SWIG_arg_fail(6)) SWIG_fail;
25747 }
25748 }
25749 if (obj6) {
25750 {
25751 arg7 = wxString_in_helper(obj6);
25752 if (arg7 == NULL) SWIG_fail;
25753 temp7 = true;
25754 }
25755 }
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25759
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 {
25764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25765 }
25766 {
25767 if (temp7)
25768 delete arg7;
25769 }
25770 return resultobj;
25771 fail:
25772 {
25773 if (temp7)
25774 delete arg7;
25775 }
25776 return NULL;
25777 }
25778
25779
25780 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25781 PyObject *resultobj;
25782 wxWindow *arg1 = (wxWindow *) 0 ;
25783 bool arg2 = (bool) false ;
25784 bool result;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 char *kwnames[] = {
25788 (char *) "self",(char *) "force", NULL
25789 };
25790
25791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(1)) SWIG_fail;
25794 if (obj1) {
25795 {
25796 arg2 = (bool)(SWIG_As_bool(obj1));
25797 if (SWIG_arg_fail(2)) SWIG_fail;
25798 }
25799 }
25800 {
25801 PyThreadState* __tstate = wxPyBeginAllowThreads();
25802 result = (bool)(arg1)->Close(arg2);
25803
25804 wxPyEndAllowThreads(__tstate);
25805 if (PyErr_Occurred()) SWIG_fail;
25806 }
25807 {
25808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25809 }
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 bool result;
25820 PyObject * obj0 = 0 ;
25821 char *kwnames[] = {
25822 (char *) "self", NULL
25823 };
25824
25825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25827 if (SWIG_arg_fail(1)) SWIG_fail;
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 result = (bool)(arg1)->Destroy();
25831
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 {
25836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25837 }
25838 return resultobj;
25839 fail:
25840 return NULL;
25841 }
25842
25843
25844 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25845 PyObject *resultobj;
25846 wxWindow *arg1 = (wxWindow *) 0 ;
25847 bool result;
25848 PyObject * obj0 = 0 ;
25849 char *kwnames[] = {
25850 (char *) "self", NULL
25851 };
25852
25853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25855 if (SWIG_arg_fail(1)) SWIG_fail;
25856 {
25857 PyThreadState* __tstate = wxPyBeginAllowThreads();
25858 result = (bool)(arg1)->DestroyChildren();
25859
25860 wxPyEndAllowThreads(__tstate);
25861 if (PyErr_Occurred()) SWIG_fail;
25862 }
25863 {
25864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25865 }
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj;
25874 wxWindow *arg1 = (wxWindow *) 0 ;
25875 bool result;
25876 PyObject * obj0 = 0 ;
25877 char *kwnames[] = {
25878 (char *) "self", NULL
25879 };
25880
25881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25883 if (SWIG_arg_fail(1)) SWIG_fail;
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25887
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 {
25892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25893 }
25894 return resultobj;
25895 fail:
25896 return NULL;
25897 }
25898
25899
25900 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25901 PyObject *resultobj;
25902 wxWindow *arg1 = (wxWindow *) 0 ;
25903 wxString *arg2 = 0 ;
25904 bool temp2 = false ;
25905 PyObject * obj0 = 0 ;
25906 PyObject * obj1 = 0 ;
25907 char *kwnames[] = {
25908 (char *) "self",(char *) "label", NULL
25909 };
25910
25911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25913 if (SWIG_arg_fail(1)) SWIG_fail;
25914 {
25915 arg2 = wxString_in_helper(obj1);
25916 if (arg2 == NULL) SWIG_fail;
25917 temp2 = true;
25918 }
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 (arg1)->SetLabel((wxString const &)*arg2);
25922
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 Py_INCREF(Py_None); resultobj = Py_None;
25927 {
25928 if (temp2)
25929 delete arg2;
25930 }
25931 return resultobj;
25932 fail:
25933 {
25934 if (temp2)
25935 delete arg2;
25936 }
25937 return NULL;
25938 }
25939
25940
25941 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj;
25943 wxWindow *arg1 = (wxWindow *) 0 ;
25944 wxString result;
25945 PyObject * obj0 = 0 ;
25946 char *kwnames[] = {
25947 (char *) "self", NULL
25948 };
25949
25950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(1)) SWIG_fail;
25953 {
25954 PyThreadState* __tstate = wxPyBeginAllowThreads();
25955 result = ((wxWindow const *)arg1)->GetLabel();
25956
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 {
25961 #if wxUSE_UNICODE
25962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25963 #else
25964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25965 #endif
25966 }
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 wxString *arg2 = 0 ;
25977 bool temp2 = false ;
25978 PyObject * obj0 = 0 ;
25979 PyObject * obj1 = 0 ;
25980 char *kwnames[] = {
25981 (char *) "self",(char *) "name", NULL
25982 };
25983
25984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25986 if (SWIG_arg_fail(1)) SWIG_fail;
25987 {
25988 arg2 = wxString_in_helper(obj1);
25989 if (arg2 == NULL) SWIG_fail;
25990 temp2 = true;
25991 }
25992 {
25993 PyThreadState* __tstate = wxPyBeginAllowThreads();
25994 (arg1)->SetName((wxString const &)*arg2);
25995
25996 wxPyEndAllowThreads(__tstate);
25997 if (PyErr_Occurred()) SWIG_fail;
25998 }
25999 Py_INCREF(Py_None); resultobj = Py_None;
26000 {
26001 if (temp2)
26002 delete arg2;
26003 }
26004 return resultobj;
26005 fail:
26006 {
26007 if (temp2)
26008 delete arg2;
26009 }
26010 return NULL;
26011 }
26012
26013
26014 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26015 PyObject *resultobj;
26016 wxWindow *arg1 = (wxWindow *) 0 ;
26017 wxString result;
26018 PyObject * obj0 = 0 ;
26019 char *kwnames[] = {
26020 (char *) "self", NULL
26021 };
26022
26023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26025 if (SWIG_arg_fail(1)) SWIG_fail;
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 result = ((wxWindow const *)arg1)->GetName();
26029
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 {
26034 #if wxUSE_UNICODE
26035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26036 #else
26037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26038 #endif
26039 }
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj;
26048 wxWindow *arg1 = (wxWindow *) 0 ;
26049 wxWindowVariant arg2 ;
26050 PyObject * obj0 = 0 ;
26051 PyObject * obj1 = 0 ;
26052 char *kwnames[] = {
26053 (char *) "self",(char *) "variant", NULL
26054 };
26055
26056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26058 if (SWIG_arg_fail(1)) SWIG_fail;
26059 {
26060 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
26061 if (SWIG_arg_fail(2)) SWIG_fail;
26062 }
26063 {
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
26066
26067 wxPyEndAllowThreads(__tstate);
26068 if (PyErr_Occurred()) SWIG_fail;
26069 }
26070 Py_INCREF(Py_None); resultobj = Py_None;
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj;
26079 wxWindow *arg1 = (wxWindow *) 0 ;
26080 wxWindowVariant result;
26081 PyObject * obj0 = 0 ;
26082 char *kwnames[] = {
26083 (char *) "self", NULL
26084 };
26085
26086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26088 if (SWIG_arg_fail(1)) SWIG_fail;
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26092
26093 wxPyEndAllowThreads(__tstate);
26094 if (PyErr_Occurred()) SWIG_fail;
26095 }
26096 resultobj = SWIG_From_int((result));
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj;
26105 wxWindow *arg1 = (wxWindow *) 0 ;
26106 int arg2 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self",(char *) "winid", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 arg2 = (int)(SWIG_As_int(obj1));
26118 if (SWIG_arg_fail(2)) SWIG_fail;
26119 }
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 (arg1)->SetId(arg2);
26123
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 Py_INCREF(Py_None); resultobj = Py_None;
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj;
26136 wxWindow *arg1 = (wxWindow *) 0 ;
26137 int result;
26138 PyObject * obj0 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 result = (int)((wxWindow const *)arg1)->GetId();
26149
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 {
26154 resultobj = SWIG_From_int((int)(result));
26155 }
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26163 PyObject *resultobj;
26164 int result;
26165 char *kwnames[] = {
26166 NULL
26167 };
26168
26169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = (int)wxWindow::NewControlId();
26173
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 {
26178 resultobj = SWIG_From_int((int)(result));
26179 }
26180 return resultobj;
26181 fail:
26182 return NULL;
26183 }
26184
26185
26186 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26187 PyObject *resultobj;
26188 int arg1 ;
26189 int result;
26190 PyObject * obj0 = 0 ;
26191 char *kwnames[] = {
26192 (char *) "winid", NULL
26193 };
26194
26195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26196 {
26197 arg1 = (int)(SWIG_As_int(obj0));
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 }
26200 {
26201 PyThreadState* __tstate = wxPyBeginAllowThreads();
26202 result = (int)wxWindow::NextControlId(arg1);
26203
26204 wxPyEndAllowThreads(__tstate);
26205 if (PyErr_Occurred()) SWIG_fail;
26206 }
26207 {
26208 resultobj = SWIG_From_int((int)(result));
26209 }
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 int arg1 ;
26219 int result;
26220 PyObject * obj0 = 0 ;
26221 char *kwnames[] = {
26222 (char *) "winid", NULL
26223 };
26224
26225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26226 {
26227 arg1 = (int)(SWIG_As_int(obj0));
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = (int)wxWindow::PrevControlId(arg1);
26233
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 {
26238 resultobj = SWIG_From_int((int)(result));
26239 }
26240 return resultobj;
26241 fail:
26242 return NULL;
26243 }
26244
26245
26246 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26247 PyObject *resultobj;
26248 wxWindow *arg1 = (wxWindow *) 0 ;
26249 wxSize *arg2 = 0 ;
26250 wxSize temp2 ;
26251 PyObject * obj0 = 0 ;
26252 PyObject * obj1 = 0 ;
26253 char *kwnames[] = {
26254 (char *) "self",(char *) "size", NULL
26255 };
26256
26257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26259 if (SWIG_arg_fail(1)) SWIG_fail;
26260 {
26261 arg2 = &temp2;
26262 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26263 }
26264 {
26265 PyThreadState* __tstate = wxPyBeginAllowThreads();
26266 (arg1)->SetSize((wxSize const &)*arg2);
26267
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 Py_INCREF(Py_None); resultobj = Py_None;
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj;
26280 wxWindow *arg1 = (wxWindow *) 0 ;
26281 int arg2 ;
26282 int arg3 ;
26283 int arg4 ;
26284 int arg5 ;
26285 int arg6 = (int) wxSIZE_AUTO ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 PyObject * obj2 = 0 ;
26289 PyObject * obj3 = 0 ;
26290 PyObject * obj4 = 0 ;
26291 PyObject * obj5 = 0 ;
26292 char *kwnames[] = {
26293 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26294 };
26295
26296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26298 if (SWIG_arg_fail(1)) SWIG_fail;
26299 {
26300 arg2 = (int)(SWIG_As_int(obj1));
26301 if (SWIG_arg_fail(2)) SWIG_fail;
26302 }
26303 {
26304 arg3 = (int)(SWIG_As_int(obj2));
26305 if (SWIG_arg_fail(3)) SWIG_fail;
26306 }
26307 {
26308 arg4 = (int)(SWIG_As_int(obj3));
26309 if (SWIG_arg_fail(4)) SWIG_fail;
26310 }
26311 {
26312 arg5 = (int)(SWIG_As_int(obj4));
26313 if (SWIG_arg_fail(5)) SWIG_fail;
26314 }
26315 if (obj5) {
26316 {
26317 arg6 = (int)(SWIG_As_int(obj5));
26318 if (SWIG_arg_fail(6)) SWIG_fail;
26319 }
26320 }
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26324
26325 wxPyEndAllowThreads(__tstate);
26326 if (PyErr_Occurred()) SWIG_fail;
26327 }
26328 Py_INCREF(Py_None); resultobj = Py_None;
26329 return resultobj;
26330 fail:
26331 return NULL;
26332 }
26333
26334
26335 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26336 PyObject *resultobj;
26337 wxWindow *arg1 = (wxWindow *) 0 ;
26338 wxRect *arg2 = 0 ;
26339 int arg3 = (int) wxSIZE_AUTO ;
26340 wxRect temp2 ;
26341 PyObject * obj0 = 0 ;
26342 PyObject * obj1 = 0 ;
26343 PyObject * obj2 = 0 ;
26344 char *kwnames[] = {
26345 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26346 };
26347
26348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26350 if (SWIG_arg_fail(1)) SWIG_fail;
26351 {
26352 arg2 = &temp2;
26353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26354 }
26355 if (obj2) {
26356 {
26357 arg3 = (int)(SWIG_As_int(obj2));
26358 if (SWIG_arg_fail(3)) SWIG_fail;
26359 }
26360 }
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26364
26365 wxPyEndAllowThreads(__tstate);
26366 if (PyErr_Occurred()) SWIG_fail;
26367 }
26368 Py_INCREF(Py_None); resultobj = Py_None;
26369 return resultobj;
26370 fail:
26371 return NULL;
26372 }
26373
26374
26375 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26376 PyObject *resultobj;
26377 wxWindow *arg1 = (wxWindow *) 0 ;
26378 int arg2 ;
26379 int arg3 ;
26380 PyObject * obj0 = 0 ;
26381 PyObject * obj1 = 0 ;
26382 PyObject * obj2 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self",(char *) "width",(char *) "height", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 arg2 = (int)(SWIG_As_int(obj1));
26392 if (SWIG_arg_fail(2)) SWIG_fail;
26393 }
26394 {
26395 arg3 = (int)(SWIG_As_int(obj2));
26396 if (SWIG_arg_fail(3)) SWIG_fail;
26397 }
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 (arg1)->SetSize(arg2,arg3);
26401
26402 wxPyEndAllowThreads(__tstate);
26403 if (PyErr_Occurred()) SWIG_fail;
26404 }
26405 Py_INCREF(Py_None); resultobj = Py_None;
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj;
26414 wxWindow *arg1 = (wxWindow *) 0 ;
26415 wxPoint *arg2 = 0 ;
26416 int arg3 = (int) wxSIZE_USE_EXISTING ;
26417 wxPoint temp2 ;
26418 PyObject * obj0 = 0 ;
26419 PyObject * obj1 = 0 ;
26420 PyObject * obj2 = 0 ;
26421 char *kwnames[] = {
26422 (char *) "self",(char *) "pt",(char *) "flags", NULL
26423 };
26424
26425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26427 if (SWIG_arg_fail(1)) SWIG_fail;
26428 {
26429 arg2 = &temp2;
26430 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26431 }
26432 if (obj2) {
26433 {
26434 arg3 = (int)(SWIG_As_int(obj2));
26435 if (SWIG_arg_fail(3)) SWIG_fail;
26436 }
26437 }
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 (arg1)->Move((wxPoint const &)*arg2,arg3);
26441
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 Py_INCREF(Py_None); resultobj = Py_None;
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj;
26454 wxWindow *arg1 = (wxWindow *) 0 ;
26455 int arg2 ;
26456 int arg3 ;
26457 int arg4 = (int) wxSIZE_USE_EXISTING ;
26458 PyObject * obj0 = 0 ;
26459 PyObject * obj1 = 0 ;
26460 PyObject * obj2 = 0 ;
26461 PyObject * obj3 = 0 ;
26462 char *kwnames[] = {
26463 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26464 };
26465
26466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26468 if (SWIG_arg_fail(1)) SWIG_fail;
26469 {
26470 arg2 = (int)(SWIG_As_int(obj1));
26471 if (SWIG_arg_fail(2)) SWIG_fail;
26472 }
26473 {
26474 arg3 = (int)(SWIG_As_int(obj2));
26475 if (SWIG_arg_fail(3)) SWIG_fail;
26476 }
26477 if (obj3) {
26478 {
26479 arg4 = (int)(SWIG_As_int(obj3));
26480 if (SWIG_arg_fail(4)) SWIG_fail;
26481 }
26482 }
26483 {
26484 PyThreadState* __tstate = wxPyBeginAllowThreads();
26485 (arg1)->Move(arg2,arg3,arg4);
26486
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 Py_INCREF(Py_None); resultobj = Py_None;
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26498 PyObject *resultobj;
26499 wxWindow *arg1 = (wxWindow *) 0 ;
26500 wxSize const &arg2_defvalue = wxDefaultSize ;
26501 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26502 wxSize temp2 ;
26503 PyObject * obj0 = 0 ;
26504 PyObject * obj1 = 0 ;
26505 char *kwnames[] = {
26506 (char *) "self",(char *) "size", NULL
26507 };
26508
26509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26511 if (SWIG_arg_fail(1)) SWIG_fail;
26512 if (obj1) {
26513 {
26514 arg2 = &temp2;
26515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26516 }
26517 }
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 Py_INCREF(Py_None); resultobj = Py_None;
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26533 PyObject *resultobj;
26534 wxWindow *arg1 = (wxWindow *) 0 ;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "self", NULL
26538 };
26539
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 (arg1)->Raise();
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 Py_INCREF(Py_None); resultobj = Py_None;
26551 return resultobj;
26552 fail:
26553 return NULL;
26554 }
26555
26556
26557 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26558 PyObject *resultobj;
26559 wxWindow *arg1 = (wxWindow *) 0 ;
26560 PyObject * obj0 = 0 ;
26561 char *kwnames[] = {
26562 (char *) "self", NULL
26563 };
26564
26565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26567 if (SWIG_arg_fail(1)) SWIG_fail;
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 (arg1)->Lower();
26571
26572 wxPyEndAllowThreads(__tstate);
26573 if (PyErr_Occurred()) SWIG_fail;
26574 }
26575 Py_INCREF(Py_None); resultobj = Py_None;
26576 return resultobj;
26577 fail:
26578 return NULL;
26579 }
26580
26581
26582 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26583 PyObject *resultobj;
26584 wxWindow *arg1 = (wxWindow *) 0 ;
26585 wxSize *arg2 = 0 ;
26586 wxSize temp2 ;
26587 PyObject * obj0 = 0 ;
26588 PyObject * obj1 = 0 ;
26589 char *kwnames[] = {
26590 (char *) "self",(char *) "size", NULL
26591 };
26592
26593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26595 if (SWIG_arg_fail(1)) SWIG_fail;
26596 {
26597 arg2 = &temp2;
26598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26599 }
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 (arg1)->SetClientSize((wxSize const &)*arg2);
26603
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 Py_INCREF(Py_None); resultobj = Py_None;
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26615 PyObject *resultobj;
26616 wxWindow *arg1 = (wxWindow *) 0 ;
26617 int arg2 ;
26618 int arg3 ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 PyObject * obj2 = 0 ;
26622 char *kwnames[] = {
26623 (char *) "self",(char *) "width",(char *) "height", NULL
26624 };
26625
26626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26628 if (SWIG_arg_fail(1)) SWIG_fail;
26629 {
26630 arg2 = (int)(SWIG_As_int(obj1));
26631 if (SWIG_arg_fail(2)) SWIG_fail;
26632 }
26633 {
26634 arg3 = (int)(SWIG_As_int(obj2));
26635 if (SWIG_arg_fail(3)) SWIG_fail;
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 (arg1)->SetClientSize(arg2,arg3);
26640
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 Py_INCREF(Py_None); resultobj = Py_None;
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 wxRect *arg2 = 0 ;
26655 wxRect temp2 ;
26656 PyObject * obj0 = 0 ;
26657 PyObject * obj1 = 0 ;
26658 char *kwnames[] = {
26659 (char *) "self",(char *) "rect", NULL
26660 };
26661
26662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26664 if (SWIG_arg_fail(1)) SWIG_fail;
26665 {
26666 arg2 = &temp2;
26667 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26668 }
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 (arg1)->SetClientSize((wxRect const &)*arg2);
26672
26673 wxPyEndAllowThreads(__tstate);
26674 if (PyErr_Occurred()) SWIG_fail;
26675 }
26676 Py_INCREF(Py_None); resultobj = Py_None;
26677 return resultobj;
26678 fail:
26679 return NULL;
26680 }
26681
26682
26683 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26684 PyObject *resultobj;
26685 wxWindow *arg1 = (wxWindow *) 0 ;
26686 wxPoint result;
26687 PyObject * obj0 = 0 ;
26688 char *kwnames[] = {
26689 (char *) "self", NULL
26690 };
26691
26692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26694 if (SWIG_arg_fail(1)) SWIG_fail;
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 result = (arg1)->GetPosition();
26698
26699 wxPyEndAllowThreads(__tstate);
26700 if (PyErr_Occurred()) SWIG_fail;
26701 }
26702 {
26703 wxPoint * resultptr;
26704 resultptr = new wxPoint((wxPoint &)(result));
26705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26706 }
26707 return resultobj;
26708 fail:
26709 return NULL;
26710 }
26711
26712
26713 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26714 PyObject *resultobj;
26715 wxWindow *arg1 = (wxWindow *) 0 ;
26716 int *arg2 = (int *) 0 ;
26717 int *arg3 = (int *) 0 ;
26718 int temp2 ;
26719 int res2 = 0 ;
26720 int temp3 ;
26721 int res3 = 0 ;
26722 PyObject * obj0 = 0 ;
26723 char *kwnames[] = {
26724 (char *) "self", NULL
26725 };
26726
26727 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26728 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26731 if (SWIG_arg_fail(1)) SWIG_fail;
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 (arg1)->GetPosition(arg2,arg3);
26735
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 Py_INCREF(Py_None); resultobj = Py_None;
26740 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26741 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26742 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26743 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26744 return resultobj;
26745 fail:
26746 return NULL;
26747 }
26748
26749
26750 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj;
26752 wxWindow *arg1 = (wxWindow *) 0 ;
26753 wxSize result;
26754 PyObject * obj0 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "self", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(1)) SWIG_fail;
26762 {
26763 PyThreadState* __tstate = wxPyBeginAllowThreads();
26764 result = ((wxWindow const *)arg1)->GetSize();
26765
26766 wxPyEndAllowThreads(__tstate);
26767 if (PyErr_Occurred()) SWIG_fail;
26768 }
26769 {
26770 wxSize * resultptr;
26771 resultptr = new wxSize((wxSize &)(result));
26772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26773 }
26774 return resultobj;
26775 fail:
26776 return NULL;
26777 }
26778
26779
26780 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj;
26782 wxWindow *arg1 = (wxWindow *) 0 ;
26783 int *arg2 = (int *) 0 ;
26784 int *arg3 = (int *) 0 ;
26785 int temp2 ;
26786 int res2 = 0 ;
26787 int temp3 ;
26788 int res3 = 0 ;
26789 PyObject * obj0 = 0 ;
26790 char *kwnames[] = {
26791 (char *) "self", NULL
26792 };
26793
26794 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26795 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26798 if (SWIG_arg_fail(1)) SWIG_fail;
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26802
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 Py_INCREF(Py_None); resultobj = Py_None;
26807 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26808 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26809 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26810 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26811 return resultobj;
26812 fail:
26813 return NULL;
26814 }
26815
26816
26817 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26818 PyObject *resultobj;
26819 wxWindow *arg1 = (wxWindow *) 0 ;
26820 wxRect result;
26821 PyObject * obj0 = 0 ;
26822 char *kwnames[] = {
26823 (char *) "self", NULL
26824 };
26825
26826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26828 if (SWIG_arg_fail(1)) SWIG_fail;
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = ((wxWindow const *)arg1)->GetRect();
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 {
26837 wxRect * resultptr;
26838 resultptr = new wxRect((wxRect &)(result));
26839 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26840 }
26841 return resultobj;
26842 fail:
26843 return NULL;
26844 }
26845
26846
26847 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26848 PyObject *resultobj;
26849 wxWindow *arg1 = (wxWindow *) 0 ;
26850 wxSize result;
26851 PyObject * obj0 = 0 ;
26852 char *kwnames[] = {
26853 (char *) "self", NULL
26854 };
26855
26856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26858 if (SWIG_arg_fail(1)) SWIG_fail;
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 result = ((wxWindow const *)arg1)->GetClientSize();
26862
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 {
26867 wxSize * resultptr;
26868 resultptr = new wxSize((wxSize &)(result));
26869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26870 }
26871 return resultobj;
26872 fail:
26873 return NULL;
26874 }
26875
26876
26877 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj;
26879 wxWindow *arg1 = (wxWindow *) 0 ;
26880 int *arg2 = (int *) 0 ;
26881 int *arg3 = (int *) 0 ;
26882 int temp2 ;
26883 int res2 = 0 ;
26884 int temp3 ;
26885 int res3 = 0 ;
26886 PyObject * obj0 = 0 ;
26887 char *kwnames[] = {
26888 (char *) "self", NULL
26889 };
26890
26891 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26892 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26899
26900 wxPyEndAllowThreads(__tstate);
26901 if (PyErr_Occurred()) SWIG_fail;
26902 }
26903 Py_INCREF(Py_None); resultobj = Py_None;
26904 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26905 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26906 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26907 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26908 return resultobj;
26909 fail:
26910 return NULL;
26911 }
26912
26913
26914 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26915 PyObject *resultobj;
26916 wxWindow *arg1 = (wxWindow *) 0 ;
26917 wxPoint result;
26918 PyObject * obj0 = 0 ;
26919 char *kwnames[] = {
26920 (char *) "self", NULL
26921 };
26922
26923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26925 if (SWIG_arg_fail(1)) SWIG_fail;
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26929
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 {
26934 wxPoint * resultptr;
26935 resultptr = new wxPoint((wxPoint &)(result));
26936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26937 }
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj;
26946 wxWindow *arg1 = (wxWindow *) 0 ;
26947 wxRect result;
26948 PyObject * obj0 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26955 if (SWIG_arg_fail(1)) SWIG_fail;
26956 {
26957 PyThreadState* __tstate = wxPyBeginAllowThreads();
26958 result = ((wxWindow const *)arg1)->GetClientRect();
26959
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 {
26964 wxRect * resultptr;
26965 resultptr = new wxRect((wxRect &)(result));
26966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26967 }
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj;
26976 wxWindow *arg1 = (wxWindow *) 0 ;
26977 wxSize result;
26978 PyObject * obj0 = 0 ;
26979 char *kwnames[] = {
26980 (char *) "self", NULL
26981 };
26982
26983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26985 if (SWIG_arg_fail(1)) SWIG_fail;
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 result = ((wxWindow const *)arg1)->GetBestSize();
26989
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 {
26994 wxSize * resultptr;
26995 resultptr = new wxSize((wxSize &)(result));
26996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj;
27006 wxWindow *arg1 = (wxWindow *) 0 ;
27007 int *arg2 = (int *) 0 ;
27008 int *arg3 = (int *) 0 ;
27009 int temp2 ;
27010 int res2 = 0 ;
27011 int temp3 ;
27012 int res3 = 0 ;
27013 PyObject * obj0 = 0 ;
27014 char *kwnames[] = {
27015 (char *) "self", NULL
27016 };
27017
27018 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27019 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27022 if (SWIG_arg_fail(1)) SWIG_fail;
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 Py_INCREF(Py_None); resultobj = Py_None;
27031 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27032 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27033 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27034 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27035 return resultobj;
27036 fail:
27037 return NULL;
27038 }
27039
27040
27041 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27042 PyObject *resultobj;
27043 wxWindow *arg1 = (wxWindow *) 0 ;
27044 PyObject * obj0 = 0 ;
27045 char *kwnames[] = {
27046 (char *) "self", NULL
27047 };
27048
27049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27051 if (SWIG_arg_fail(1)) SWIG_fail;
27052 {
27053 PyThreadState* __tstate = wxPyBeginAllowThreads();
27054 (arg1)->InvalidateBestSize();
27055
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 Py_INCREF(Py_None); resultobj = Py_None;
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj;
27068 wxWindow *arg1 = (wxWindow *) 0 ;
27069 wxSize *arg2 = 0 ;
27070 wxSize temp2 ;
27071 PyObject * obj0 = 0 ;
27072 PyObject * obj1 = 0 ;
27073 char *kwnames[] = {
27074 (char *) "self",(char *) "size", NULL
27075 };
27076
27077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(1)) SWIG_fail;
27080 {
27081 arg2 = &temp2;
27082 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 Py_INCREF(Py_None); resultobj = Py_None;
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj;
27100 wxWindow *arg1 = (wxWindow *) 0 ;
27101 wxSize result;
27102 PyObject * obj0 = 0 ;
27103 char *kwnames[] = {
27104 (char *) "self", NULL
27105 };
27106
27107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27109 if (SWIG_arg_fail(1)) SWIG_fail;
27110 {
27111 PyThreadState* __tstate = wxPyBeginAllowThreads();
27112 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27113
27114 wxPyEndAllowThreads(__tstate);
27115 if (PyErr_Occurred()) SWIG_fail;
27116 }
27117 {
27118 wxSize * resultptr;
27119 resultptr = new wxSize((wxSize &)(result));
27120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27121 }
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxWindow *arg1 = (wxWindow *) 0 ;
27131 wxSize result;
27132 PyObject * obj0 = 0 ;
27133 char *kwnames[] = {
27134 (char *) "self", NULL
27135 };
27136
27137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(1)) SWIG_fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27143
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 wxSize * resultptr;
27149 resultptr = new wxSize((wxSize &)(result));
27150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27151 }
27152 return resultobj;
27153 fail:
27154 return NULL;
27155 }
27156
27157
27158 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27159 PyObject *resultobj;
27160 wxWindow *arg1 = (wxWindow *) 0 ;
27161 int arg2 = (int) wxBOTH ;
27162 PyObject * obj0 = 0 ;
27163 PyObject * obj1 = 0 ;
27164 char *kwnames[] = {
27165 (char *) "self",(char *) "direction", NULL
27166 };
27167
27168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27170 if (SWIG_arg_fail(1)) SWIG_fail;
27171 if (obj1) {
27172 {
27173 arg2 = (int)(SWIG_As_int(obj1));
27174 if (SWIG_arg_fail(2)) SWIG_fail;
27175 }
27176 }
27177 {
27178 PyThreadState* __tstate = wxPyBeginAllowThreads();
27179 (arg1)->Center(arg2);
27180
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 Py_INCREF(Py_None); resultobj = Py_None;
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj;
27193 wxWindow *arg1 = (wxWindow *) 0 ;
27194 int arg2 = (int) wxBOTH ;
27195 PyObject * obj0 = 0 ;
27196 PyObject * obj1 = 0 ;
27197 char *kwnames[] = {
27198 (char *) "self",(char *) "dir", NULL
27199 };
27200
27201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27203 if (SWIG_arg_fail(1)) SWIG_fail;
27204 if (obj1) {
27205 {
27206 arg2 = (int)(SWIG_As_int(obj1));
27207 if (SWIG_arg_fail(2)) SWIG_fail;
27208 }
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 (arg1)->CenterOnScreen(arg2);
27213
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 Py_INCREF(Py_None); resultobj = Py_None;
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27225 PyObject *resultobj;
27226 wxWindow *arg1 = (wxWindow *) 0 ;
27227 int arg2 = (int) wxBOTH ;
27228 PyObject * obj0 = 0 ;
27229 PyObject * obj1 = 0 ;
27230 char *kwnames[] = {
27231 (char *) "self",(char *) "dir", NULL
27232 };
27233
27234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27236 if (SWIG_arg_fail(1)) SWIG_fail;
27237 if (obj1) {
27238 {
27239 arg2 = (int)(SWIG_As_int(obj1));
27240 if (SWIG_arg_fail(2)) SWIG_fail;
27241 }
27242 }
27243 {
27244 PyThreadState* __tstate = wxPyBeginAllowThreads();
27245 (arg1)->CenterOnParent(arg2);
27246
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 Py_INCREF(Py_None); resultobj = Py_None;
27251 return resultobj;
27252 fail:
27253 return NULL;
27254 }
27255
27256
27257 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27258 PyObject *resultobj;
27259 wxWindow *arg1 = (wxWindow *) 0 ;
27260 PyObject * obj0 = 0 ;
27261 char *kwnames[] = {
27262 (char *) "self", NULL
27263 };
27264
27265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27267 if (SWIG_arg_fail(1)) SWIG_fail;
27268 {
27269 PyThreadState* __tstate = wxPyBeginAllowThreads();
27270 (arg1)->Fit();
27271
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 Py_INCREF(Py_None); resultobj = Py_None;
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27283 PyObject *resultobj;
27284 wxWindow *arg1 = (wxWindow *) 0 ;
27285 PyObject * obj0 = 0 ;
27286 char *kwnames[] = {
27287 (char *) "self", NULL
27288 };
27289
27290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27292 if (SWIG_arg_fail(1)) SWIG_fail;
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 (arg1)->FitInside();
27296
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 Py_INCREF(Py_None); resultobj = Py_None;
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27308 PyObject *resultobj;
27309 wxWindow *arg1 = (wxWindow *) 0 ;
27310 int arg2 ;
27311 int arg3 ;
27312 int arg4 = (int) -1 ;
27313 int arg5 = (int) -1 ;
27314 int arg6 = (int) -1 ;
27315 int arg7 = (int) -1 ;
27316 PyObject * obj0 = 0 ;
27317 PyObject * obj1 = 0 ;
27318 PyObject * obj2 = 0 ;
27319 PyObject * obj3 = 0 ;
27320 PyObject * obj4 = 0 ;
27321 PyObject * obj5 = 0 ;
27322 PyObject * obj6 = 0 ;
27323 char *kwnames[] = {
27324 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27325 };
27326
27327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27329 if (SWIG_arg_fail(1)) SWIG_fail;
27330 {
27331 arg2 = (int)(SWIG_As_int(obj1));
27332 if (SWIG_arg_fail(2)) SWIG_fail;
27333 }
27334 {
27335 arg3 = (int)(SWIG_As_int(obj2));
27336 if (SWIG_arg_fail(3)) SWIG_fail;
27337 }
27338 if (obj3) {
27339 {
27340 arg4 = (int)(SWIG_As_int(obj3));
27341 if (SWIG_arg_fail(4)) SWIG_fail;
27342 }
27343 }
27344 if (obj4) {
27345 {
27346 arg5 = (int)(SWIG_As_int(obj4));
27347 if (SWIG_arg_fail(5)) SWIG_fail;
27348 }
27349 }
27350 if (obj5) {
27351 {
27352 arg6 = (int)(SWIG_As_int(obj5));
27353 if (SWIG_arg_fail(6)) SWIG_fail;
27354 }
27355 }
27356 if (obj6) {
27357 {
27358 arg7 = (int)(SWIG_As_int(obj6));
27359 if (SWIG_arg_fail(7)) SWIG_fail;
27360 }
27361 }
27362 {
27363 PyThreadState* __tstate = wxPyBeginAllowThreads();
27364 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27365
27366 wxPyEndAllowThreads(__tstate);
27367 if (PyErr_Occurred()) SWIG_fail;
27368 }
27369 Py_INCREF(Py_None); resultobj = Py_None;
27370 return resultobj;
27371 fail:
27372 return NULL;
27373 }
27374
27375
27376 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27377 PyObject *resultobj;
27378 wxWindow *arg1 = (wxWindow *) 0 ;
27379 wxSize *arg2 = 0 ;
27380 wxSize const &arg3_defvalue = wxDefaultSize ;
27381 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27382 wxSize const &arg4_defvalue = wxDefaultSize ;
27383 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27384 wxSize temp2 ;
27385 wxSize temp3 ;
27386 wxSize temp4 ;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 PyObject * obj2 = 0 ;
27390 PyObject * obj3 = 0 ;
27391 char *kwnames[] = {
27392 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27393 };
27394
27395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27397 if (SWIG_arg_fail(1)) SWIG_fail;
27398 {
27399 arg2 = &temp2;
27400 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27401 }
27402 if (obj2) {
27403 {
27404 arg3 = &temp3;
27405 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27406 }
27407 }
27408 if (obj3) {
27409 {
27410 arg4 = &temp4;
27411 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27412 }
27413 }
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27417
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 Py_INCREF(Py_None); resultobj = Py_None;
27422 return resultobj;
27423 fail:
27424 return NULL;
27425 }
27426
27427
27428 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj;
27430 wxWindow *arg1 = (wxWindow *) 0 ;
27431 int arg2 ;
27432 int arg3 ;
27433 int arg4 = (int) -1 ;
27434 int arg5 = (int) -1 ;
27435 PyObject * obj0 = 0 ;
27436 PyObject * obj1 = 0 ;
27437 PyObject * obj2 = 0 ;
27438 PyObject * obj3 = 0 ;
27439 PyObject * obj4 = 0 ;
27440 char *kwnames[] = {
27441 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27442 };
27443
27444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27446 if (SWIG_arg_fail(1)) SWIG_fail;
27447 {
27448 arg2 = (int)(SWIG_As_int(obj1));
27449 if (SWIG_arg_fail(2)) SWIG_fail;
27450 }
27451 {
27452 arg3 = (int)(SWIG_As_int(obj2));
27453 if (SWIG_arg_fail(3)) SWIG_fail;
27454 }
27455 if (obj3) {
27456 {
27457 arg4 = (int)(SWIG_As_int(obj3));
27458 if (SWIG_arg_fail(4)) SWIG_fail;
27459 }
27460 }
27461 if (obj4) {
27462 {
27463 arg5 = (int)(SWIG_As_int(obj4));
27464 if (SWIG_arg_fail(5)) SWIG_fail;
27465 }
27466 }
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 Py_INCREF(Py_None); resultobj = Py_None;
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27482 PyObject *resultobj;
27483 wxWindow *arg1 = (wxWindow *) 0 ;
27484 wxSize *arg2 = 0 ;
27485 wxSize const &arg3_defvalue = wxDefaultSize ;
27486 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27487 wxSize temp2 ;
27488 wxSize temp3 ;
27489 PyObject * obj0 = 0 ;
27490 PyObject * obj1 = 0 ;
27491 PyObject * obj2 = 0 ;
27492 char *kwnames[] = {
27493 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27494 };
27495
27496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27498 if (SWIG_arg_fail(1)) SWIG_fail;
27499 {
27500 arg2 = &temp2;
27501 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27502 }
27503 if (obj2) {
27504 {
27505 arg3 = &temp3;
27506 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27507 }
27508 }
27509 {
27510 PyThreadState* __tstate = wxPyBeginAllowThreads();
27511 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27512
27513 wxPyEndAllowThreads(__tstate);
27514 if (PyErr_Occurred()) SWIG_fail;
27515 }
27516 Py_INCREF(Py_None); resultobj = Py_None;
27517 return resultobj;
27518 fail:
27519 return NULL;
27520 }
27521
27522
27523 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27524 PyObject *resultobj;
27525 wxWindow *arg1 = (wxWindow *) 0 ;
27526 wxSize result;
27527 PyObject * obj0 = 0 ;
27528 char *kwnames[] = {
27529 (char *) "self", NULL
27530 };
27531
27532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27534 if (SWIG_arg_fail(1)) SWIG_fail;
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = ((wxWindow const *)arg1)->GetMaxSize();
27538
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 {
27543 wxSize * resultptr;
27544 resultptr = new wxSize((wxSize &)(result));
27545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27546 }
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj;
27555 wxWindow *arg1 = (wxWindow *) 0 ;
27556 wxSize result;
27557 PyObject * obj0 = 0 ;
27558 char *kwnames[] = {
27559 (char *) "self", NULL
27560 };
27561
27562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(1)) SWIG_fail;
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 result = ((wxWindow const *)arg1)->GetMinSize();
27568
27569 wxPyEndAllowThreads(__tstate);
27570 if (PyErr_Occurred()) SWIG_fail;
27571 }
27572 {
27573 wxSize * resultptr;
27574 resultptr = new wxSize((wxSize &)(result));
27575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27576 }
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27584 PyObject *resultobj;
27585 wxWindow *arg1 = (wxWindow *) 0 ;
27586 wxSize *arg2 = 0 ;
27587 wxSize temp2 ;
27588 PyObject * obj0 = 0 ;
27589 PyObject * obj1 = 0 ;
27590 char *kwnames[] = {
27591 (char *) "self",(char *) "minSize", NULL
27592 };
27593
27594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27596 if (SWIG_arg_fail(1)) SWIG_fail;
27597 {
27598 arg2 = &temp2;
27599 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27600 }
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 (arg1)->SetMinSize((wxSize const &)*arg2);
27604
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 Py_INCREF(Py_None); resultobj = Py_None;
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27616 PyObject *resultobj;
27617 wxWindow *arg1 = (wxWindow *) 0 ;
27618 wxSize *arg2 = 0 ;
27619 wxSize temp2 ;
27620 PyObject * obj0 = 0 ;
27621 PyObject * obj1 = 0 ;
27622 char *kwnames[] = {
27623 (char *) "self",(char *) "maxSize", NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27628 if (SWIG_arg_fail(1)) SWIG_fail;
27629 {
27630 arg2 = &temp2;
27631 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27632 }
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 (arg1)->SetMaxSize((wxSize const &)*arg2);
27636
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 Py_INCREF(Py_None); resultobj = Py_None;
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj;
27649 wxWindow *arg1 = (wxWindow *) 0 ;
27650 int result;
27651 PyObject * obj0 = 0 ;
27652 char *kwnames[] = {
27653 (char *) "self", NULL
27654 };
27655
27656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27658 if (SWIG_arg_fail(1)) SWIG_fail;
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27662
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 {
27667 resultobj = SWIG_From_int((int)(result));
27668 }
27669 return resultobj;
27670 fail:
27671 return NULL;
27672 }
27673
27674
27675 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27676 PyObject *resultobj;
27677 wxWindow *arg1 = (wxWindow *) 0 ;
27678 int result;
27679 PyObject * obj0 = 0 ;
27680 char *kwnames[] = {
27681 (char *) "self", NULL
27682 };
27683
27684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27686 if (SWIG_arg_fail(1)) SWIG_fail;
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27690
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 {
27695 resultobj = SWIG_From_int((int)(result));
27696 }
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj;
27705 wxWindow *arg1 = (wxWindow *) 0 ;
27706 int result;
27707 PyObject * obj0 = 0 ;
27708 char *kwnames[] = {
27709 (char *) "self", NULL
27710 };
27711
27712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27714 if (SWIG_arg_fail(1)) SWIG_fail;
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 resultobj = SWIG_From_int((int)(result));
27724 }
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj;
27733 wxWindow *arg1 = (wxWindow *) 0 ;
27734 int result;
27735 PyObject * obj0 = 0 ;
27736 char *kwnames[] = {
27737 (char *) "self", NULL
27738 };
27739
27740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27742 if (SWIG_arg_fail(1)) SWIG_fail;
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27746
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 {
27751 resultobj = SWIG_From_int((int)(result));
27752 }
27753 return resultobj;
27754 fail:
27755 return NULL;
27756 }
27757
27758
27759 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27760 PyObject *resultobj;
27761 wxWindow *arg1 = (wxWindow *) 0 ;
27762 wxSize *arg2 = 0 ;
27763 wxSize temp2 ;
27764 PyObject * obj0 = 0 ;
27765 PyObject * obj1 = 0 ;
27766 char *kwnames[] = {
27767 (char *) "self",(char *) "size", NULL
27768 };
27769
27770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27772 if (SWIG_arg_fail(1)) SWIG_fail;
27773 {
27774 arg2 = &temp2;
27775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27776 }
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 Py_INCREF(Py_None); resultobj = Py_None;
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27792 PyObject *resultobj;
27793 wxWindow *arg1 = (wxWindow *) 0 ;
27794 int arg2 ;
27795 int arg3 ;
27796 PyObject * obj0 = 0 ;
27797 PyObject * obj1 = 0 ;
27798 PyObject * obj2 = 0 ;
27799 char *kwnames[] = {
27800 (char *) "self",(char *) "w",(char *) "h", NULL
27801 };
27802
27803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27805 if (SWIG_arg_fail(1)) SWIG_fail;
27806 {
27807 arg2 = (int)(SWIG_As_int(obj1));
27808 if (SWIG_arg_fail(2)) SWIG_fail;
27809 }
27810 {
27811 arg3 = (int)(SWIG_As_int(obj2));
27812 if (SWIG_arg_fail(3)) SWIG_fail;
27813 }
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->SetVirtualSize(arg2,arg3);
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 Py_INCREF(Py_None); resultobj = Py_None;
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj;
27830 wxWindow *arg1 = (wxWindow *) 0 ;
27831 wxSize result;
27832 PyObject * obj0 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = ((wxWindow const *)arg1)->GetVirtualSize();
27843
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 {
27848 wxSize * resultptr;
27849 resultptr = new wxSize((wxSize &)(result));
27850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 int *arg2 = (int *) 0 ;
27862 int *arg3 = (int *) 0 ;
27863 int temp2 ;
27864 int res2 = 0 ;
27865 int temp3 ;
27866 int res3 = 0 ;
27867 PyObject * obj0 = 0 ;
27868 char *kwnames[] = {
27869 (char *) "self", NULL
27870 };
27871
27872 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27873 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27876 if (SWIG_arg_fail(1)) SWIG_fail;
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27880
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 Py_INCREF(Py_None); resultobj = Py_None;
27885 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27886 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27887 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27888 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj;
27897 wxWindow *arg1 = (wxWindow *) 0 ;
27898 wxSize result;
27899 PyObject * obj0 = 0 ;
27900 char *kwnames[] = {
27901 (char *) "self", NULL
27902 };
27903
27904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27906 if (SWIG_arg_fail(1)) SWIG_fail;
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27910
27911 wxPyEndAllowThreads(__tstate);
27912 if (PyErr_Occurred()) SWIG_fail;
27913 }
27914 {
27915 wxSize * resultptr;
27916 resultptr = new wxSize((wxSize &)(result));
27917 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27918 }
27919 return resultobj;
27920 fail:
27921 return NULL;
27922 }
27923
27924
27925 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27926 PyObject *resultobj;
27927 wxWindow *arg1 = (wxWindow *) 0 ;
27928 bool arg2 = (bool) true ;
27929 bool result;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 char *kwnames[] = {
27933 (char *) "self",(char *) "show", NULL
27934 };
27935
27936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27938 if (SWIG_arg_fail(1)) SWIG_fail;
27939 if (obj1) {
27940 {
27941 arg2 = (bool)(SWIG_As_bool(obj1));
27942 if (SWIG_arg_fail(2)) SWIG_fail;
27943 }
27944 }
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (bool)(arg1)->Show(arg2);
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 bool result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (bool)(arg1)->Hide();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 bool arg2 = (bool) true ;
27993 bool result;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char *kwnames[] = {
27997 (char *) "self",(char *) "enable", NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28002 if (SWIG_arg_fail(1)) SWIG_fail;
28003 if (obj1) {
28004 {
28005 arg2 = (bool)(SWIG_As_bool(obj1));
28006 if (SWIG_arg_fail(2)) SWIG_fail;
28007 }
28008 }
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 result = (bool)(arg1)->Enable(arg2);
28012
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 {
28017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28018 }
28019 return resultobj;
28020 fail:
28021 return NULL;
28022 }
28023
28024
28025 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28026 PyObject *resultobj;
28027 wxWindow *arg1 = (wxWindow *) 0 ;
28028 bool result;
28029 PyObject * obj0 = 0 ;
28030 char *kwnames[] = {
28031 (char *) "self", NULL
28032 };
28033
28034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(1)) SWIG_fail;
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (bool)(arg1)->Disable();
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj;
28055 wxWindow *arg1 = (wxWindow *) 0 ;
28056 bool result;
28057 PyObject * obj0 = 0 ;
28058 char *kwnames[] = {
28059 (char *) "self", NULL
28060 };
28061
28062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28064 if (SWIG_arg_fail(1)) SWIG_fail;
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 result = (bool)((wxWindow const *)arg1)->IsShown();
28068
28069 wxPyEndAllowThreads(__tstate);
28070 if (PyErr_Occurred()) SWIG_fail;
28071 }
28072 {
28073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28074 }
28075 return resultobj;
28076 fail:
28077 return NULL;
28078 }
28079
28080
28081 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj;
28083 wxWindow *arg1 = (wxWindow *) 0 ;
28084 bool result;
28085 PyObject * obj0 = 0 ;
28086 char *kwnames[] = {
28087 (char *) "self", NULL
28088 };
28089
28090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28092 if (SWIG_arg_fail(1)) SWIG_fail;
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28096
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 {
28101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28102 }
28103 return resultobj;
28104 fail:
28105 return NULL;
28106 }
28107
28108
28109 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28110 PyObject *resultobj;
28111 wxWindow *arg1 = (wxWindow *) 0 ;
28112 long arg2 ;
28113 PyObject * obj0 = 0 ;
28114 PyObject * obj1 = 0 ;
28115 char *kwnames[] = {
28116 (char *) "self",(char *) "style", NULL
28117 };
28118
28119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28121 if (SWIG_arg_fail(1)) SWIG_fail;
28122 {
28123 arg2 = (long)(SWIG_As_long(obj1));
28124 if (SWIG_arg_fail(2)) SWIG_fail;
28125 }
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 (arg1)->SetWindowStyleFlag(arg2);
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 Py_INCREF(Py_None); resultobj = Py_None;
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28141 PyObject *resultobj;
28142 wxWindow *arg1 = (wxWindow *) 0 ;
28143 long result;
28144 PyObject * obj0 = 0 ;
28145 char *kwnames[] = {
28146 (char *) "self", NULL
28147 };
28148
28149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28151 if (SWIG_arg_fail(1)) SWIG_fail;
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28155
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 {
28160 resultobj = SWIG_From_long((long)(result));
28161 }
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj;
28170 wxWindow *arg1 = (wxWindow *) 0 ;
28171 int arg2 ;
28172 bool result;
28173 PyObject * obj0 = 0 ;
28174 PyObject * obj1 = 0 ;
28175 char *kwnames[] = {
28176 (char *) "self",(char *) "flag", NULL
28177 };
28178
28179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28181 if (SWIG_arg_fail(1)) SWIG_fail;
28182 {
28183 arg2 = (int)(SWIG_As_int(obj1));
28184 if (SWIG_arg_fail(2)) SWIG_fail;
28185 }
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28195 }
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 bool result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (bool)((wxWindow const *)arg1)->IsRetained();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxWindow *arg1 = (wxWindow *) 0 ;
28233 long arg2 ;
28234 PyObject * obj0 = 0 ;
28235 PyObject * obj1 = 0 ;
28236 char *kwnames[] = {
28237 (char *) "self",(char *) "exStyle", NULL
28238 };
28239
28240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28242 if (SWIG_arg_fail(1)) SWIG_fail;
28243 {
28244 arg2 = (long)(SWIG_As_long(obj1));
28245 if (SWIG_arg_fail(2)) SWIG_fail;
28246 }
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 (arg1)->SetExtraStyle(arg2);
28250
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 Py_INCREF(Py_None); resultobj = Py_None;
28255 return resultobj;
28256 fail:
28257 return NULL;
28258 }
28259
28260
28261 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28262 PyObject *resultobj;
28263 wxWindow *arg1 = (wxWindow *) 0 ;
28264 long result;
28265 PyObject * obj0 = 0 ;
28266 char *kwnames[] = {
28267 (char *) "self", NULL
28268 };
28269
28270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28272 if (SWIG_arg_fail(1)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28276
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 {
28281 resultobj = SWIG_From_long((long)(result));
28282 }
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj;
28291 wxWindow *arg1 = (wxWindow *) 0 ;
28292 bool arg2 = (bool) true ;
28293 PyObject * obj0 = 0 ;
28294 PyObject * obj1 = 0 ;
28295 char *kwnames[] = {
28296 (char *) "self",(char *) "modal", NULL
28297 };
28298
28299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28301 if (SWIG_arg_fail(1)) SWIG_fail;
28302 if (obj1) {
28303 {
28304 arg2 = (bool)(SWIG_As_bool(obj1));
28305 if (SWIG_arg_fail(2)) SWIG_fail;
28306 }
28307 }
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 (arg1)->MakeModal(arg2);
28311
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 Py_INCREF(Py_None); resultobj = Py_None;
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28323 PyObject *resultobj;
28324 wxWindow *arg1 = (wxWindow *) 0 ;
28325 bool arg2 ;
28326 PyObject * obj0 = 0 ;
28327 PyObject * obj1 = 0 ;
28328 char *kwnames[] = {
28329 (char *) "self",(char *) "enableTheme", NULL
28330 };
28331
28332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28334 if (SWIG_arg_fail(1)) SWIG_fail;
28335 {
28336 arg2 = (bool)(SWIG_As_bool(obj1));
28337 if (SWIG_arg_fail(2)) SWIG_fail;
28338 }
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 (arg1)->SetThemeEnabled(arg2);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 Py_INCREF(Py_None); resultobj = Py_None;
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28354 PyObject *resultobj;
28355 wxWindow *arg1 = (wxWindow *) 0 ;
28356 bool result;
28357 PyObject * obj0 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 {
28373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28374 }
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj;
28383 wxWindow *arg1 = (wxWindow *) 0 ;
28384 PyObject * obj0 = 0 ;
28385 char *kwnames[] = {
28386 (char *) "self", NULL
28387 };
28388
28389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28391 if (SWIG_arg_fail(1)) SWIG_fail;
28392 {
28393 PyThreadState* __tstate = wxPyBeginAllowThreads();
28394 (arg1)->SetFocus();
28395
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 Py_INCREF(Py_None); resultobj = Py_None;
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj;
28408 wxWindow *arg1 = (wxWindow *) 0 ;
28409 PyObject * obj0 = 0 ;
28410 char *kwnames[] = {
28411 (char *) "self", NULL
28412 };
28413
28414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28416 if (SWIG_arg_fail(1)) SWIG_fail;
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 (arg1)->SetFocusFromKbd();
28420
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 Py_INCREF(Py_None); resultobj = Py_None;
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj;
28433 wxWindow *result;
28434 char *kwnames[] = {
28435 NULL
28436 };
28437
28438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28439 {
28440 if (!wxPyCheckForApp()) SWIG_fail;
28441 PyThreadState* __tstate = wxPyBeginAllowThreads();
28442 result = (wxWindow *)wxWindow::FindFocus();
28443
28444 wxPyEndAllowThreads(__tstate);
28445 if (PyErr_Occurred()) SWIG_fail;
28446 }
28447 {
28448 resultobj = wxPyMake_wxObject(result, 0);
28449 }
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj;
28458 wxWindow *arg1 = (wxWindow *) 0 ;
28459 bool result;
28460 PyObject * obj0 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28471
28472 wxPyEndAllowThreads(__tstate);
28473 if (PyErr_Occurred()) SWIG_fail;
28474 }
28475 {
28476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28477 }
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj;
28486 wxWindow *arg1 = (wxWindow *) 0 ;
28487 bool result;
28488 PyObject * obj0 = 0 ;
28489 char *kwnames[] = {
28490 (char *) "self", NULL
28491 };
28492
28493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28495 if (SWIG_arg_fail(1)) SWIG_fail;
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28499
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 {
28504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28505 }
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28513 PyObject *resultobj;
28514 wxWindow *arg1 = (wxWindow *) 0 ;
28515 wxWindow *result;
28516 PyObject * obj0 = 0 ;
28517 char *kwnames[] = {
28518 (char *) "self", NULL
28519 };
28520
28521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28523 if (SWIG_arg_fail(1)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28527
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 {
28532 resultobj = wxPyMake_wxObject(result, 0);
28533 }
28534 return resultobj;
28535 fail:
28536 return NULL;
28537 }
28538
28539
28540 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28541 PyObject *resultobj;
28542 wxWindow *arg1 = (wxWindow *) 0 ;
28543 wxWindow *arg2 = (wxWindow *) 0 ;
28544 wxWindow *result;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "child", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(2)) SWIG_fail;
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28559
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 {
28564 resultobj = wxPyMake_wxObject(result, 0);
28565 }
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj;
28574 wxWindow *arg1 = (wxWindow *) 0 ;
28575 wxWindow *arg2 = (wxWindow *) 0 ;
28576 PyObject * obj0 = 0 ;
28577 PyObject * obj1 = 0 ;
28578 char *kwnames[] = {
28579 (char *) "self",(char *) "win", NULL
28580 };
28581
28582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28584 if (SWIG_arg_fail(1)) SWIG_fail;
28585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(2)) SWIG_fail;
28587 {
28588 PyThreadState* __tstate = wxPyBeginAllowThreads();
28589 (arg1)->SetTmpDefaultItem(arg2);
28590
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 Py_INCREF(Py_None); resultobj = Py_None;
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28602 PyObject *resultobj;
28603 wxWindow *arg1 = (wxWindow *) 0 ;
28604 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28605 bool result;
28606 PyObject * obj0 = 0 ;
28607 PyObject * obj1 = 0 ;
28608 char *kwnames[] = {
28609 (char *) "self",(char *) "flags", NULL
28610 };
28611
28612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28614 if (SWIG_arg_fail(1)) SWIG_fail;
28615 if (obj1) {
28616 {
28617 arg2 = (int)(SWIG_As_int(obj1));
28618 if (SWIG_arg_fail(2)) SWIG_fail;
28619 }
28620 }
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = (bool)(arg1)->Navigate(arg2);
28624
28625 wxPyEndAllowThreads(__tstate);
28626 if (PyErr_Occurred()) SWIG_fail;
28627 }
28628 {
28629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28630 }
28631 return resultobj;
28632 fail:
28633 return NULL;
28634 }
28635
28636
28637 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28638 PyObject *resultobj;
28639 wxWindow *arg1 = (wxWindow *) 0 ;
28640 wxWindow *arg2 = (wxWindow *) 0 ;
28641 PyObject * obj0 = 0 ;
28642 PyObject * obj1 = 0 ;
28643 char *kwnames[] = {
28644 (char *) "self",(char *) "win", NULL
28645 };
28646
28647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28649 if (SWIG_arg_fail(1)) SWIG_fail;
28650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28651 if (SWIG_arg_fail(2)) SWIG_fail;
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 (arg1)->MoveAfterInTabOrder(arg2);
28655
28656 wxPyEndAllowThreads(__tstate);
28657 if (PyErr_Occurred()) SWIG_fail;
28658 }
28659 Py_INCREF(Py_None); resultobj = Py_None;
28660 return resultobj;
28661 fail:
28662 return NULL;
28663 }
28664
28665
28666 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28667 PyObject *resultobj;
28668 wxWindow *arg1 = (wxWindow *) 0 ;
28669 wxWindow *arg2 = (wxWindow *) 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 char *kwnames[] = {
28673 (char *) "self",(char *) "win", NULL
28674 };
28675
28676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28678 if (SWIG_arg_fail(1)) SWIG_fail;
28679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(2)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 (arg1)->MoveBeforeInTabOrder(arg2);
28684
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 Py_INCREF(Py_None); resultobj = Py_None;
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj;
28697 wxWindow *arg1 = (wxWindow *) 0 ;
28698 PyObject *result;
28699 PyObject * obj0 = 0 ;
28700 char *kwnames[] = {
28701 (char *) "self", NULL
28702 };
28703
28704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28706 if (SWIG_arg_fail(1)) SWIG_fail;
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = (PyObject *)wxWindow_GetChildren(arg1);
28710
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 resultobj = result;
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28722 PyObject *resultobj;
28723 wxWindow *arg1 = (wxWindow *) 0 ;
28724 wxWindow *result;
28725 PyObject * obj0 = 0 ;
28726 char *kwnames[] = {
28727 (char *) "self", NULL
28728 };
28729
28730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28732 if (SWIG_arg_fail(1)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28736
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 {
28741 resultobj = wxPyMake_wxObject(result, 0);
28742 }
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28750 PyObject *resultobj;
28751 wxWindow *arg1 = (wxWindow *) 0 ;
28752 wxWindow *result;
28753 PyObject * obj0 = 0 ;
28754 char *kwnames[] = {
28755 (char *) "self", NULL
28756 };
28757
28758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 resultobj = wxPyMake_wxObject(result, 0);
28770 }
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28778 PyObject *resultobj;
28779 wxWindow *arg1 = (wxWindow *) 0 ;
28780 bool result;
28781 PyObject * obj0 = 0 ;
28782 char *kwnames[] = {
28783 (char *) "self", NULL
28784 };
28785
28786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28788 if (SWIG_arg_fail(1)) SWIG_fail;
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28792
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 {
28797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28798 }
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj;
28807 wxWindow *arg1 = (wxWindow *) 0 ;
28808 wxWindow *arg2 = (wxWindow *) 0 ;
28809 bool result;
28810 PyObject * obj0 = 0 ;
28811 PyObject * obj1 = 0 ;
28812 char *kwnames[] = {
28813 (char *) "self",(char *) "newParent", NULL
28814 };
28815
28816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28818 if (SWIG_arg_fail(1)) SWIG_fail;
28819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28820 if (SWIG_arg_fail(2)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = (bool)(arg1)->Reparent(arg2);
28824
28825 wxPyEndAllowThreads(__tstate);
28826 if (PyErr_Occurred()) SWIG_fail;
28827 }
28828 {
28829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28830 }
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj;
28839 wxWindow *arg1 = (wxWindow *) 0 ;
28840 wxWindow *arg2 = (wxWindow *) 0 ;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 char *kwnames[] = {
28844 (char *) "self",(char *) "child", NULL
28845 };
28846
28847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28849 if (SWIG_arg_fail(1)) SWIG_fail;
28850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(2)) SWIG_fail;
28852 {
28853 PyThreadState* __tstate = wxPyBeginAllowThreads();
28854 (arg1)->AddChild(arg2);
28855
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 Py_INCREF(Py_None); resultobj = Py_None;
28860 return resultobj;
28861 fail:
28862 return NULL;
28863 }
28864
28865
28866 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28867 PyObject *resultobj;
28868 wxWindow *arg1 = (wxWindow *) 0 ;
28869 wxWindow *arg2 = (wxWindow *) 0 ;
28870 PyObject * obj0 = 0 ;
28871 PyObject * obj1 = 0 ;
28872 char *kwnames[] = {
28873 (char *) "self",(char *) "child", NULL
28874 };
28875
28876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28878 if (SWIG_arg_fail(1)) SWIG_fail;
28879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28880 if (SWIG_arg_fail(2)) SWIG_fail;
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 (arg1)->RemoveChild(arg2);
28884
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 Py_INCREF(Py_None); resultobj = Py_None;
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28896 PyObject *resultobj;
28897 wxWindow *arg1 = (wxWindow *) 0 ;
28898 long arg2 ;
28899 wxWindow *result;
28900 PyObject * obj0 = 0 ;
28901 PyObject * obj1 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self",(char *) "winid", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 arg2 = (long)(SWIG_As_long(obj1));
28911 if (SWIG_arg_fail(2)) SWIG_fail;
28912 }
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (wxWindow *)(arg1)->FindWindow(arg2);
28916
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 {
28921 resultobj = wxPyMake_wxObject(result, 0);
28922 }
28923 return resultobj;
28924 fail:
28925 return NULL;
28926 }
28927
28928
28929 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28930 PyObject *resultobj;
28931 wxWindow *arg1 = (wxWindow *) 0 ;
28932 wxString *arg2 = 0 ;
28933 wxWindow *result;
28934 bool temp2 = false ;
28935 PyObject * obj0 = 0 ;
28936 PyObject * obj1 = 0 ;
28937 char *kwnames[] = {
28938 (char *) "self",(char *) "name", NULL
28939 };
28940
28941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28943 if (SWIG_arg_fail(1)) SWIG_fail;
28944 {
28945 arg2 = wxString_in_helper(obj1);
28946 if (arg2 == NULL) SWIG_fail;
28947 temp2 = true;
28948 }
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28952
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 {
28957 resultobj = wxPyMake_wxObject(result, 0);
28958 }
28959 {
28960 if (temp2)
28961 delete arg2;
28962 }
28963 return resultobj;
28964 fail:
28965 {
28966 if (temp2)
28967 delete arg2;
28968 }
28969 return NULL;
28970 }
28971
28972
28973 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxWindow *arg1 = (wxWindow *) 0 ;
28976 wxEvtHandler *result;
28977 PyObject * obj0 = 0 ;
28978 char *kwnames[] = {
28979 (char *) "self", NULL
28980 };
28981
28982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28984 if (SWIG_arg_fail(1)) SWIG_fail;
28985 {
28986 PyThreadState* __tstate = wxPyBeginAllowThreads();
28987 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28988
28989 wxPyEndAllowThreads(__tstate);
28990 if (PyErr_Occurred()) SWIG_fail;
28991 }
28992 {
28993 resultobj = wxPyMake_wxObject(result, 0);
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj;
29003 wxWindow *arg1 = (wxWindow *) 0 ;
29004 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29005 PyObject * obj0 = 0 ;
29006 PyObject * obj1 = 0 ;
29007 char *kwnames[] = {
29008 (char *) "self",(char *) "handler", NULL
29009 };
29010
29011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29013 if (SWIG_arg_fail(1)) SWIG_fail;
29014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(2)) SWIG_fail;
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 (arg1)->SetEventHandler(arg2);
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 Py_INCREF(Py_None); resultobj = Py_None;
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj;
29032 wxWindow *arg1 = (wxWindow *) 0 ;
29033 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29034 PyObject * obj0 = 0 ;
29035 PyObject * obj1 = 0 ;
29036 char *kwnames[] = {
29037 (char *) "self",(char *) "handler", NULL
29038 };
29039
29040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29042 if (SWIG_arg_fail(1)) SWIG_fail;
29043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29044 if (SWIG_arg_fail(2)) SWIG_fail;
29045 {
29046 PyThreadState* __tstate = wxPyBeginAllowThreads();
29047 (arg1)->PushEventHandler(arg2);
29048
29049 wxPyEndAllowThreads(__tstate);
29050 if (PyErr_Occurred()) SWIG_fail;
29051 }
29052 Py_INCREF(Py_None); resultobj = Py_None;
29053 return resultobj;
29054 fail:
29055 return NULL;
29056 }
29057
29058
29059 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29060 PyObject *resultobj;
29061 wxWindow *arg1 = (wxWindow *) 0 ;
29062 bool arg2 = (bool) false ;
29063 wxEvtHandler *result;
29064 PyObject * obj0 = 0 ;
29065 PyObject * obj1 = 0 ;
29066 char *kwnames[] = {
29067 (char *) "self",(char *) "deleteHandler", NULL
29068 };
29069
29070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29072 if (SWIG_arg_fail(1)) SWIG_fail;
29073 if (obj1) {
29074 {
29075 arg2 = (bool)(SWIG_As_bool(obj1));
29076 if (SWIG_arg_fail(2)) SWIG_fail;
29077 }
29078 }
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 {
29087 resultobj = wxPyMake_wxObject(result, 0);
29088 }
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29096 PyObject *resultobj;
29097 wxWindow *arg1 = (wxWindow *) 0 ;
29098 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29099 bool result;
29100 PyObject * obj0 = 0 ;
29101 PyObject * obj1 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "handler", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(2)) SWIG_fail;
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 result = (bool)(arg1)->RemoveEventHandler(arg2);
29114
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 {
29119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29120 }
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj;
29129 wxWindow *arg1 = (wxWindow *) 0 ;
29130 wxValidator *arg2 = 0 ;
29131 PyObject * obj0 = 0 ;
29132 PyObject * obj1 = 0 ;
29133 char *kwnames[] = {
29134 (char *) "self",(char *) "validator", NULL
29135 };
29136
29137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29139 if (SWIG_arg_fail(1)) SWIG_fail;
29140 {
29141 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29142 if (SWIG_arg_fail(2)) SWIG_fail;
29143 if (arg2 == NULL) {
29144 SWIG_null_ref("wxValidator");
29145 }
29146 if (SWIG_arg_fail(2)) SWIG_fail;
29147 }
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 (arg1)->SetValidator((wxValidator const &)*arg2);
29151
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 Py_INCREF(Py_None); resultobj = Py_None;
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29163 PyObject *resultobj;
29164 wxWindow *arg1 = (wxWindow *) 0 ;
29165 wxValidator *result;
29166 PyObject * obj0 = 0 ;
29167 char *kwnames[] = {
29168 (char *) "self", NULL
29169 };
29170
29171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 {
29175 PyThreadState* __tstate = wxPyBeginAllowThreads();
29176 result = (wxValidator *)(arg1)->GetValidator();
29177
29178 wxPyEndAllowThreads(__tstate);
29179 if (PyErr_Occurred()) SWIG_fail;
29180 }
29181 {
29182 resultobj = wxPyMake_wxObject(result, 0);
29183 }
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29191 PyObject *resultobj;
29192 wxWindow *arg1 = (wxWindow *) 0 ;
29193 bool result;
29194 PyObject * obj0 = 0 ;
29195 char *kwnames[] = {
29196 (char *) "self", NULL
29197 };
29198
29199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29201 if (SWIG_arg_fail(1)) SWIG_fail;
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = (bool)(arg1)->Validate();
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_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj;
29220 wxWindow *arg1 = (wxWindow *) 0 ;
29221 bool result;
29222 PyObject * obj0 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "self", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",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 = (bool)(arg1)->TransferDataToWindow();
29233
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 {
29238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29239 }
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxWindow *arg1 = (wxWindow *) 0 ;
29249 bool result;
29250 PyObject * obj0 = 0 ;
29251 char *kwnames[] = {
29252 (char *) "self", NULL
29253 };
29254
29255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(1)) SWIG_fail;
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 result = (bool)(arg1)->TransferDataFromWindow();
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 {
29266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29267 }
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29275 PyObject *resultobj;
29276 wxWindow *arg1 = (wxWindow *) 0 ;
29277 PyObject * obj0 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 (arg1)->InitDialog();
29288
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 Py_INCREF(Py_None); resultobj = Py_None;
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj;
29301 wxWindow *arg1 = (wxWindow *) 0 ;
29302 wxAcceleratorTable *arg2 = 0 ;
29303 PyObject * obj0 = 0 ;
29304 PyObject * obj1 = 0 ;
29305 char *kwnames[] = {
29306 (char *) "self",(char *) "accel", NULL
29307 };
29308
29309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29311 if (SWIG_arg_fail(1)) SWIG_fail;
29312 {
29313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29314 if (SWIG_arg_fail(2)) SWIG_fail;
29315 if (arg2 == NULL) {
29316 SWIG_null_ref("wxAcceleratorTable");
29317 }
29318 if (SWIG_arg_fail(2)) SWIG_fail;
29319 }
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29323
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 Py_INCREF(Py_None); resultobj = Py_None;
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29335 PyObject *resultobj;
29336 wxWindow *arg1 = (wxWindow *) 0 ;
29337 wxAcceleratorTable *result;
29338 PyObject * obj0 = 0 ;
29339 char *kwnames[] = {
29340 (char *) "self", NULL
29341 };
29342
29343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29345 if (SWIG_arg_fail(1)) SWIG_fail;
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29349
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj;
29362 wxWindow *arg1 = (wxWindow *) 0 ;
29363 int arg2 ;
29364 int arg3 ;
29365 int arg4 ;
29366 bool result;
29367 PyObject * obj0 = 0 ;
29368 PyObject * obj1 = 0 ;
29369 PyObject * obj2 = 0 ;
29370 PyObject * obj3 = 0 ;
29371 char *kwnames[] = {
29372 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29373 };
29374
29375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29377 if (SWIG_arg_fail(1)) SWIG_fail;
29378 {
29379 arg2 = (int)(SWIG_As_int(obj1));
29380 if (SWIG_arg_fail(2)) SWIG_fail;
29381 }
29382 {
29383 arg3 = (int)(SWIG_As_int(obj2));
29384 if (SWIG_arg_fail(3)) SWIG_fail;
29385 }
29386 {
29387 arg4 = (int)(SWIG_As_int(obj3));
29388 if (SWIG_arg_fail(4)) SWIG_fail;
29389 }
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29393
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 {
29398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29399 }
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 int arg2 ;
29410 bool result;
29411 PyObject * obj0 = 0 ;
29412 PyObject * obj1 = 0 ;
29413 char *kwnames[] = {
29414 (char *) "self",(char *) "hotkeyId", NULL
29415 };
29416
29417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29419 if (SWIG_arg_fail(1)) SWIG_fail;
29420 {
29421 arg2 = (int)(SWIG_As_int(obj1));
29422 if (SWIG_arg_fail(2)) SWIG_fail;
29423 }
29424 {
29425 PyThreadState* __tstate = wxPyBeginAllowThreads();
29426 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29427
29428 wxPyEndAllowThreads(__tstate);
29429 if (PyErr_Occurred()) SWIG_fail;
29430 }
29431 {
29432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29433 }
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29441 PyObject *resultobj;
29442 wxWindow *arg1 = (wxWindow *) 0 ;
29443 wxPoint *arg2 = 0 ;
29444 wxPoint result;
29445 wxPoint temp2 ;
29446 PyObject * obj0 = 0 ;
29447 PyObject * obj1 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "self",(char *) "pt", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29454 if (SWIG_arg_fail(1)) SWIG_fail;
29455 {
29456 arg2 = &temp2;
29457 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29458 }
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29462
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 {
29467 wxPoint * resultptr;
29468 resultptr = new wxPoint((wxPoint &)(result));
29469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29470 }
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj;
29479 wxWindow *arg1 = (wxWindow *) 0 ;
29480 wxSize *arg2 = 0 ;
29481 wxSize result;
29482 wxSize temp2 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char *kwnames[] = {
29486 (char *) "self",(char *) "sz", NULL
29487 };
29488
29489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29491 if (SWIG_arg_fail(1)) SWIG_fail;
29492 {
29493 arg2 = &temp2;
29494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29495 }
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29499
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 {
29504 wxSize * resultptr;
29505 resultptr = new wxSize((wxSize &)(result));
29506 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29507 }
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29515 PyObject *resultobj;
29516 wxWindow *arg1 = (wxWindow *) 0 ;
29517 wxPoint *arg2 = 0 ;
29518 wxPoint result;
29519 wxPoint temp2 ;
29520 PyObject * obj0 = 0 ;
29521 PyObject * obj1 = 0 ;
29522 char *kwnames[] = {
29523 (char *) "self",(char *) "pt", NULL
29524 };
29525
29526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29528 if (SWIG_arg_fail(1)) SWIG_fail;
29529 {
29530 arg2 = &temp2;
29531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29532 }
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29536
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 {
29541 wxPoint * resultptr;
29542 resultptr = new wxPoint((wxPoint &)(result));
29543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29544 }
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29552 PyObject *resultobj;
29553 wxWindow *arg1 = (wxWindow *) 0 ;
29554 wxSize *arg2 = 0 ;
29555 wxSize result;
29556 wxSize temp2 ;
29557 PyObject * obj0 = 0 ;
29558 PyObject * obj1 = 0 ;
29559 char *kwnames[] = {
29560 (char *) "self",(char *) "sz", NULL
29561 };
29562
29563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29565 if (SWIG_arg_fail(1)) SWIG_fail;
29566 {
29567 arg2 = &temp2;
29568 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29569 }
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29573
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 {
29578 wxSize * resultptr;
29579 resultptr = new wxSize((wxSize &)(result));
29580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29581 }
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj;
29590 wxWindow *arg1 = (wxWindow *) 0 ;
29591 wxPoint *arg2 = 0 ;
29592 wxPoint result;
29593 wxPoint temp2 ;
29594 PyObject * obj0 = 0 ;
29595 PyObject * obj1 = 0 ;
29596 char *kwnames[] = {
29597 (char *) "self",(char *) "pt", NULL
29598 };
29599
29600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29602 if (SWIG_arg_fail(1)) SWIG_fail;
29603 {
29604 arg2 = &temp2;
29605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29606 }
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29610
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 wxPoint * resultptr;
29616 resultptr = new wxPoint((wxPoint &)(result));
29617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29618 }
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj;
29627 wxWindow *arg1 = (wxWindow *) 0 ;
29628 wxSize *arg2 = 0 ;
29629 wxSize result;
29630 wxSize temp2 ;
29631 PyObject * obj0 = 0 ;
29632 PyObject * obj1 = 0 ;
29633 char *kwnames[] = {
29634 (char *) "self",(char *) "sz", NULL
29635 };
29636
29637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29639 if (SWIG_arg_fail(1)) SWIG_fail;
29640 {
29641 arg2 = &temp2;
29642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29643 }
29644 {
29645 PyThreadState* __tstate = wxPyBeginAllowThreads();
29646 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29647
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 {
29652 wxSize * resultptr;
29653 resultptr = new wxSize((wxSize &)(result));
29654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29655 }
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj;
29664 wxWindow *arg1 = (wxWindow *) 0 ;
29665 int arg2 ;
29666 int arg3 ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 PyObject * obj2 = 0 ;
29670 char *kwnames[] = {
29671 (char *) "self",(char *) "x",(char *) "y", NULL
29672 };
29673
29674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 {
29678 arg2 = (int)(SWIG_As_int(obj1));
29679 if (SWIG_arg_fail(2)) SWIG_fail;
29680 }
29681 {
29682 arg3 = (int)(SWIG_As_int(obj2));
29683 if (SWIG_arg_fail(3)) SWIG_fail;
29684 }
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 (arg1)->WarpPointer(arg2,arg3);
29688
29689 wxPyEndAllowThreads(__tstate);
29690 if (PyErr_Occurred()) SWIG_fail;
29691 }
29692 Py_INCREF(Py_None); resultobj = Py_None;
29693 return resultobj;
29694 fail:
29695 return NULL;
29696 }
29697
29698
29699 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29700 PyObject *resultobj;
29701 wxWindow *arg1 = (wxWindow *) 0 ;
29702 PyObject * obj0 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 (arg1)->CaptureMouse();
29713
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 Py_INCREF(Py_None); resultobj = Py_None;
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 PyObject * obj0 = 0 ;
29728 char *kwnames[] = {
29729 (char *) "self", NULL
29730 };
29731
29732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29734 if (SWIG_arg_fail(1)) SWIG_fail;
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 (arg1)->ReleaseMouse();
29738
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 Py_INCREF(Py_None); resultobj = Py_None;
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj;
29751 wxWindow *result;
29752 char *kwnames[] = {
29753 NULL
29754 };
29755
29756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29757 {
29758 if (!wxPyCheckForApp()) SWIG_fail;
29759 PyThreadState* __tstate = wxPyBeginAllowThreads();
29760 result = (wxWindow *)wxWindow::GetCapture();
29761
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 {
29766 resultobj = wxPyMake_wxObject(result, 0);
29767 }
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 bool result;
29778 PyObject * obj0 = 0 ;
29779 char *kwnames[] = {
29780 (char *) "self", NULL
29781 };
29782
29783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29785 if (SWIG_arg_fail(1)) SWIG_fail;
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 result = (bool)((wxWindow const *)arg1)->HasCapture();
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 {
29794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29795 }
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj;
29804 wxWindow *arg1 = (wxWindow *) 0 ;
29805 bool arg2 = (bool) true ;
29806 wxRect *arg3 = (wxRect *) NULL ;
29807 PyObject * obj0 = 0 ;
29808 PyObject * obj1 = 0 ;
29809 PyObject * obj2 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 if (obj1) {
29818 {
29819 arg2 = (bool)(SWIG_As_bool(obj1));
29820 if (SWIG_arg_fail(2)) SWIG_fail;
29821 }
29822 }
29823 if (obj2) {
29824 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29825 if (SWIG_arg_fail(3)) SWIG_fail;
29826 }
29827 {
29828 PyThreadState* __tstate = wxPyBeginAllowThreads();
29829 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29830
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 Py_INCREF(Py_None); resultobj = Py_None;
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29842 PyObject *resultobj;
29843 wxWindow *arg1 = (wxWindow *) 0 ;
29844 wxRect *arg2 = 0 ;
29845 bool arg3 = (bool) true ;
29846 wxRect temp2 ;
29847 PyObject * obj0 = 0 ;
29848 PyObject * obj1 = 0 ;
29849 PyObject * obj2 = 0 ;
29850 char *kwnames[] = {
29851 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29852 };
29853
29854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(1)) SWIG_fail;
29857 {
29858 arg2 = &temp2;
29859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29860 }
29861 if (obj2) {
29862 {
29863 arg3 = (bool)(SWIG_As_bool(obj2));
29864 if (SWIG_arg_fail(3)) SWIG_fail;
29865 }
29866 }
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29870
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 Py_INCREF(Py_None); resultobj = Py_None;
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 PyObject * obj0 = 0 ;
29885 char *kwnames[] = {
29886 (char *) "self", NULL
29887 };
29888
29889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29891 if (SWIG_arg_fail(1)) SWIG_fail;
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->Update();
29895
29896 wxPyEndAllowThreads(__tstate);
29897 if (PyErr_Occurred()) SWIG_fail;
29898 }
29899 Py_INCREF(Py_None); resultobj = Py_None;
29900 return resultobj;
29901 fail:
29902 return NULL;
29903 }
29904
29905
29906 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29907 PyObject *resultobj;
29908 wxWindow *arg1 = (wxWindow *) 0 ;
29909 PyObject * obj0 = 0 ;
29910 char *kwnames[] = {
29911 (char *) "self", NULL
29912 };
29913
29914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29916 if (SWIG_arg_fail(1)) SWIG_fail;
29917 {
29918 PyThreadState* __tstate = wxPyBeginAllowThreads();
29919 (arg1)->ClearBackground();
29920
29921 wxPyEndAllowThreads(__tstate);
29922 if (PyErr_Occurred()) SWIG_fail;
29923 }
29924 Py_INCREF(Py_None); resultobj = Py_None;
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29932 PyObject *resultobj;
29933 wxWindow *arg1 = (wxWindow *) 0 ;
29934 PyObject * obj0 = 0 ;
29935 char *kwnames[] = {
29936 (char *) "self", NULL
29937 };
29938
29939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29941 if (SWIG_arg_fail(1)) SWIG_fail;
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 (arg1)->Freeze();
29945
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 Py_INCREF(Py_None); resultobj = Py_None;
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29957 PyObject *resultobj;
29958 wxWindow *arg1 = (wxWindow *) 0 ;
29959 PyObject * obj0 = 0 ;
29960 char *kwnames[] = {
29961 (char *) "self", NULL
29962 };
29963
29964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29966 if (SWIG_arg_fail(1)) SWIG_fail;
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 (arg1)->Thaw();
29970
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 Py_INCREF(Py_None); resultobj = Py_None;
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj;
29983 wxWindow *arg1 = (wxWindow *) 0 ;
29984 wxDC *arg2 = 0 ;
29985 PyObject * obj0 = 0 ;
29986 PyObject * obj1 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self",(char *) "dc", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 {
29995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29996 if (SWIG_arg_fail(2)) SWIG_fail;
29997 if (arg2 == NULL) {
29998 SWIG_null_ref("wxDC");
29999 }
30000 if (SWIG_arg_fail(2)) SWIG_fail;
30001 }
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 (arg1)->PrepareDC(*arg2);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 Py_INCREF(Py_None); resultobj = Py_None;
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxWindow *arg1 = (wxWindow *) 0 ;
30019 wxRegion *result;
30020 PyObject * obj0 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 {
30031 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30032 result = (wxRegion *) &_result_ref;
30033 }
30034
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30046 PyObject *resultobj;
30047 wxWindow *arg1 = (wxWindow *) 0 ;
30048 wxRect result;
30049 PyObject * obj0 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(1)) SWIG_fail;
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30060
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 {
30065 wxRect * resultptr;
30066 resultptr = new wxRect((wxRect &)(result));
30067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30068 }
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj;
30077 wxWindow *arg1 = (wxWindow *) 0 ;
30078 int arg2 ;
30079 int arg3 ;
30080 int arg4 = (int) 1 ;
30081 int arg5 = (int) 1 ;
30082 bool result;
30083 PyObject * obj0 = 0 ;
30084 PyObject * obj1 = 0 ;
30085 PyObject * obj2 = 0 ;
30086 PyObject * obj3 = 0 ;
30087 PyObject * obj4 = 0 ;
30088 char *kwnames[] = {
30089 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30090 };
30091
30092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30094 if (SWIG_arg_fail(1)) SWIG_fail;
30095 {
30096 arg2 = (int)(SWIG_As_int(obj1));
30097 if (SWIG_arg_fail(2)) SWIG_fail;
30098 }
30099 {
30100 arg3 = (int)(SWIG_As_int(obj2));
30101 if (SWIG_arg_fail(3)) SWIG_fail;
30102 }
30103 if (obj3) {
30104 {
30105 arg4 = (int)(SWIG_As_int(obj3));
30106 if (SWIG_arg_fail(4)) SWIG_fail;
30107 }
30108 }
30109 if (obj4) {
30110 {
30111 arg5 = (int)(SWIG_As_int(obj4));
30112 if (SWIG_arg_fail(5)) SWIG_fail;
30113 }
30114 }
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30118
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 {
30123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj;
30133 wxWindow *arg1 = (wxWindow *) 0 ;
30134 wxPoint *arg2 = 0 ;
30135 bool result;
30136 wxPoint temp2 ;
30137 PyObject * obj0 = 0 ;
30138 PyObject * obj1 = 0 ;
30139 char *kwnames[] = {
30140 (char *) "self",(char *) "pt", NULL
30141 };
30142
30143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30145 if (SWIG_arg_fail(1)) SWIG_fail;
30146 {
30147 arg2 = &temp2;
30148 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30149 }
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30153
30154 wxPyEndAllowThreads(__tstate);
30155 if (PyErr_Occurred()) SWIG_fail;
30156 }
30157 {
30158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30159 }
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30167 PyObject *resultobj;
30168 wxWindow *arg1 = (wxWindow *) 0 ;
30169 wxRect *arg2 = 0 ;
30170 bool result;
30171 wxRect temp2 ;
30172 PyObject * obj0 = 0 ;
30173 PyObject * obj1 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self",(char *) "rect", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 {
30182 arg2 = &temp2;
30183 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30184 }
30185 {
30186 PyThreadState* __tstate = wxPyBeginAllowThreads();
30187 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30188
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 {
30193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30194 }
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30202 PyObject *resultobj;
30203 wxWindow *arg1 = (wxWindow *) 0 ;
30204 wxVisualAttributes result;
30205 PyObject * obj0 = 0 ;
30206 char *kwnames[] = {
30207 (char *) "self", NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30216
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 {
30221 wxVisualAttributes * resultptr;
30222 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30223 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30224 }
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj;
30233 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30234 wxVisualAttributes result;
30235 PyObject * obj0 = 0 ;
30236 char *kwnames[] = {
30237 (char *) "variant", NULL
30238 };
30239
30240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30241 if (obj0) {
30242 {
30243 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 }
30246 }
30247 {
30248 if (!wxPyCheckForApp()) SWIG_fail;
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 {
30256 wxVisualAttributes * resultptr;
30257 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30259 }
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30267 PyObject *resultobj;
30268 wxWindow *arg1 = (wxWindow *) 0 ;
30269 wxColour *arg2 = 0 ;
30270 bool result;
30271 wxColour temp2 ;
30272 PyObject * obj0 = 0 ;
30273 PyObject * obj1 = 0 ;
30274 char *kwnames[] = {
30275 (char *) "self",(char *) "colour", NULL
30276 };
30277
30278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30280 if (SWIG_arg_fail(1)) SWIG_fail;
30281 {
30282 arg2 = &temp2;
30283 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30284 }
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30288
30289 wxPyEndAllowThreads(__tstate);
30290 if (PyErr_Occurred()) SWIG_fail;
30291 }
30292 {
30293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30294 }
30295 return resultobj;
30296 fail:
30297 return NULL;
30298 }
30299
30300
30301 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30302 PyObject *resultobj;
30303 wxWindow *arg1 = (wxWindow *) 0 ;
30304 wxColour *arg2 = 0 ;
30305 wxColour temp2 ;
30306 PyObject * obj0 = 0 ;
30307 PyObject * obj1 = 0 ;
30308 char *kwnames[] = {
30309 (char *) "self",(char *) "colour", NULL
30310 };
30311
30312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30314 if (SWIG_arg_fail(1)) SWIG_fail;
30315 {
30316 arg2 = &temp2;
30317 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30318 }
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30322
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 Py_INCREF(Py_None); resultobj = Py_None;
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj;
30335 wxWindow *arg1 = (wxWindow *) 0 ;
30336 wxColour *arg2 = 0 ;
30337 bool result;
30338 wxColour temp2 ;
30339 PyObject * obj0 = 0 ;
30340 PyObject * obj1 = 0 ;
30341 char *kwnames[] = {
30342 (char *) "self",(char *) "colour", NULL
30343 };
30344
30345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(1)) SWIG_fail;
30348 {
30349 arg2 = &temp2;
30350 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30351 }
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 {
30360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30361 }
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj;
30370 wxWindow *arg1 = (wxWindow *) 0 ;
30371 wxColour *arg2 = 0 ;
30372 wxColour temp2 ;
30373 PyObject * obj0 = 0 ;
30374 PyObject * obj1 = 0 ;
30375 char *kwnames[] = {
30376 (char *) "self",(char *) "colour", NULL
30377 };
30378
30379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30381 if (SWIG_arg_fail(1)) SWIG_fail;
30382 {
30383 arg2 = &temp2;
30384 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30385 }
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30389
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 Py_INCREF(Py_None); resultobj = Py_None;
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj;
30402 wxWindow *arg1 = (wxWindow *) 0 ;
30403 wxColour result;
30404 PyObject * obj0 = 0 ;
30405 char *kwnames[] = {
30406 (char *) "self", NULL
30407 };
30408
30409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30411 if (SWIG_arg_fail(1)) SWIG_fail;
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30415
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 {
30420 wxColour * resultptr;
30421 resultptr = new wxColour((wxColour &)(result));
30422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30423 }
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj;
30432 wxWindow *arg1 = (wxWindow *) 0 ;
30433 wxColour result;
30434 PyObject * obj0 = 0 ;
30435 char *kwnames[] = {
30436 (char *) "self", NULL
30437 };
30438
30439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30441 if (SWIG_arg_fail(1)) SWIG_fail;
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 result = ((wxWindow const *)arg1)->GetForegroundColour();
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 {
30450 wxColour * resultptr;
30451 resultptr = new wxColour((wxColour &)(result));
30452 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30453 }
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30461 PyObject *resultobj;
30462 wxWindow *arg1 = (wxWindow *) 0 ;
30463 bool result;
30464 PyObject * obj0 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30475
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 {
30480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30481 }
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxWindow *arg1 = (wxWindow *) 0 ;
30491 bool result;
30492 PyObject * obj0 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 PyThreadState* __tstate = wxPyBeginAllowThreads();
30502 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30503
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 {
30508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30509 }
30510 return resultobj;
30511 fail:
30512 return NULL;
30513 }
30514
30515
30516 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30517 PyObject *resultobj;
30518 wxWindow *arg1 = (wxWindow *) 0 ;
30519 wxBackgroundStyle arg2 ;
30520 bool result;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 char *kwnames[] = {
30524 (char *) "self",(char *) "style", NULL
30525 };
30526
30527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30529 if (SWIG_arg_fail(1)) SWIG_fail;
30530 {
30531 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30532 if (SWIG_arg_fail(2)) SWIG_fail;
30533 }
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30537
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 {
30542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30543 }
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj;
30552 wxWindow *arg1 = (wxWindow *) 0 ;
30553 wxBackgroundStyle result;
30554 PyObject * obj0 = 0 ;
30555 char *kwnames[] = {
30556 (char *) "self", NULL
30557 };
30558
30559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30561 if (SWIG_arg_fail(1)) SWIG_fail;
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30565
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_From_int((result));
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxWindow *arg1 = (wxWindow *) 0 ;
30579 bool result;
30580 PyObject * obj0 = 0 ;
30581 char *kwnames[] = {
30582 (char *) "self", NULL
30583 };
30584
30585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30587 if (SWIG_arg_fail(1)) SWIG_fail;
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 result = (bool)(arg1)->HasTransparentBackground();
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj;
30606 wxWindow *arg1 = (wxWindow *) 0 ;
30607 wxCursor *arg2 = 0 ;
30608 bool result;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611 char *kwnames[] = {
30612 (char *) "self",(char *) "cursor", NULL
30613 };
30614
30615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30617 if (SWIG_arg_fail(1)) SWIG_fail;
30618 {
30619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30620 if (SWIG_arg_fail(2)) SWIG_fail;
30621 if (arg2 == NULL) {
30622 SWIG_null_ref("wxCursor");
30623 }
30624 if (SWIG_arg_fail(2)) SWIG_fail;
30625 }
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30629
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 {
30634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30635 }
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj;
30644 wxWindow *arg1 = (wxWindow *) 0 ;
30645 wxCursor result;
30646 PyObject * obj0 = 0 ;
30647 char *kwnames[] = {
30648 (char *) "self", NULL
30649 };
30650
30651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30653 if (SWIG_arg_fail(1)) SWIG_fail;
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (arg1)->GetCursor();
30657
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 {
30662 wxCursor * resultptr;
30663 resultptr = new wxCursor((wxCursor &)(result));
30664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30665 }
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30673 PyObject *resultobj;
30674 wxWindow *arg1 = (wxWindow *) 0 ;
30675 wxFont *arg2 = 0 ;
30676 bool result;
30677 PyObject * obj0 = 0 ;
30678 PyObject * obj1 = 0 ;
30679 char *kwnames[] = {
30680 (char *) "self",(char *) "font", NULL
30681 };
30682
30683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30685 if (SWIG_arg_fail(1)) SWIG_fail;
30686 {
30687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30688 if (SWIG_arg_fail(2)) SWIG_fail;
30689 if (arg2 == NULL) {
30690 SWIG_null_ref("wxFont");
30691 }
30692 if (SWIG_arg_fail(2)) SWIG_fail;
30693 }
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 {
30702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30703 }
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30711 PyObject *resultobj;
30712 wxWindow *arg1 = (wxWindow *) 0 ;
30713 wxFont *arg2 = 0 ;
30714 PyObject * obj0 = 0 ;
30715 PyObject * obj1 = 0 ;
30716 char *kwnames[] = {
30717 (char *) "self",(char *) "font", NULL
30718 };
30719
30720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30722 if (SWIG_arg_fail(1)) SWIG_fail;
30723 {
30724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30725 if (SWIG_arg_fail(2)) SWIG_fail;
30726 if (arg2 == NULL) {
30727 SWIG_null_ref("wxFont");
30728 }
30729 if (SWIG_arg_fail(2)) SWIG_fail;
30730 }
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 (arg1)->SetOwnFont((wxFont const &)*arg2);
30734
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 Py_INCREF(Py_None); resultobj = Py_None;
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30746 PyObject *resultobj;
30747 wxWindow *arg1 = (wxWindow *) 0 ;
30748 wxFont result;
30749 PyObject * obj0 = 0 ;
30750 char *kwnames[] = {
30751 (char *) "self", NULL
30752 };
30753
30754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30756 if (SWIG_arg_fail(1)) SWIG_fail;
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (arg1)->GetFont();
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 {
30765 wxFont * resultptr;
30766 resultptr = new wxFont((wxFont &)(result));
30767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30768 }
30769 return resultobj;
30770 fail:
30771 return NULL;
30772 }
30773
30774
30775 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30776 PyObject *resultobj;
30777 wxWindow *arg1 = (wxWindow *) 0 ;
30778 wxCaret *arg2 = (wxCaret *) 0 ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self",(char *) "caret", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(2)) SWIG_fail;
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 (arg1)->SetCaret(arg2);
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 Py_INCREF(Py_None); resultobj = Py_None;
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj;
30806 wxWindow *arg1 = (wxWindow *) 0 ;
30807 wxCaret *result;
30808 PyObject * obj0 = 0 ;
30809 char *kwnames[] = {
30810 (char *) "self", NULL
30811 };
30812
30813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30815 if (SWIG_arg_fail(1)) SWIG_fail;
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30819
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 int result;
30834 PyObject * obj0 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "self", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30841 if (SWIG_arg_fail(1)) SWIG_fail;
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30845
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 {
30850 resultobj = SWIG_From_int((int)(result));
30851 }
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30859 PyObject *resultobj;
30860 wxWindow *arg1 = (wxWindow *) 0 ;
30861 int result;
30862 PyObject * obj0 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30869 if (SWIG_arg_fail(1)) SWIG_fail;
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30873
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 {
30878 resultobj = SWIG_From_int((int)(result));
30879 }
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 wxWindow *arg1 = (wxWindow *) 0 ;
30889 wxString *arg2 = 0 ;
30890 int *arg3 = (int *) 0 ;
30891 int *arg4 = (int *) 0 ;
30892 bool temp2 = false ;
30893 int temp3 ;
30894 int res3 = 0 ;
30895 int temp4 ;
30896 int res4 = 0 ;
30897 PyObject * obj0 = 0 ;
30898 PyObject * obj1 = 0 ;
30899 char *kwnames[] = {
30900 (char *) "self",(char *) "string", NULL
30901 };
30902
30903 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30904 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(1)) SWIG_fail;
30908 {
30909 arg2 = wxString_in_helper(obj1);
30910 if (arg2 == NULL) SWIG_fail;
30911 temp2 = true;
30912 }
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 Py_INCREF(Py_None); resultobj = Py_None;
30921 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30922 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30923 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30924 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30925 {
30926 if (temp2)
30927 delete arg2;
30928 }
30929 return resultobj;
30930 fail:
30931 {
30932 if (temp2)
30933 delete arg2;
30934 }
30935 return NULL;
30936 }
30937
30938
30939 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30940 PyObject *resultobj;
30941 wxWindow *arg1 = (wxWindow *) 0 ;
30942 wxString *arg2 = 0 ;
30943 int *arg3 = (int *) 0 ;
30944 int *arg4 = (int *) 0 ;
30945 int *arg5 = (int *) 0 ;
30946 int *arg6 = (int *) 0 ;
30947 wxFont *arg7 = (wxFont *) NULL ;
30948 bool temp2 = false ;
30949 int temp3 ;
30950 int res3 = 0 ;
30951 int temp4 ;
30952 int res4 = 0 ;
30953 int temp5 ;
30954 int res5 = 0 ;
30955 int temp6 ;
30956 int res6 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 PyObject * obj2 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self",(char *) "string",(char *) "font", NULL
30962 };
30963
30964 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30965 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30966 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30967 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30970 if (SWIG_arg_fail(1)) SWIG_fail;
30971 {
30972 arg2 = wxString_in_helper(obj1);
30973 if (arg2 == NULL) SWIG_fail;
30974 temp2 = true;
30975 }
30976 if (obj2) {
30977 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(7)) SWIG_fail;
30979 }
30980 {
30981 PyThreadState* __tstate = wxPyBeginAllowThreads();
30982 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30983
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 Py_INCREF(Py_None); resultobj = Py_None;
30988 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30989 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30990 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30991 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30992 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30993 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30994 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30995 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30996 {
30997 if (temp2)
30998 delete arg2;
30999 }
31000 return resultobj;
31001 fail:
31002 {
31003 if (temp2)
31004 delete arg2;
31005 }
31006 return NULL;
31007 }
31008
31009
31010 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31011 PyObject *resultobj;
31012 wxWindow *arg1 = (wxWindow *) 0 ;
31013 int *arg2 = (int *) 0 ;
31014 int *arg3 = (int *) 0 ;
31015 int temp2 ;
31016 int res2 = 0 ;
31017 int temp3 ;
31018 int res3 = 0 ;
31019 PyObject * obj0 = 0 ;
31020 PyObject * obj1 = 0 ;
31021 PyObject * obj2 = 0 ;
31022 char *kwnames[] = {
31023 (char *) "self",(char *) "x",(char *) "y", NULL
31024 };
31025
31026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",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 {
31030 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31031 temp2 = SWIG_As_int(obj1);
31032 if (SWIG_arg_fail(2)) SWIG_fail;
31033 arg2 = &temp2;
31034 res2 = SWIG_NEWOBJ;
31035 }
31036 }
31037 {
31038 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31039 temp3 = SWIG_As_int(obj2);
31040 if (SWIG_arg_fail(3)) SWIG_fail;
31041 arg3 = &temp3;
31042 res3 = SWIG_NEWOBJ;
31043 }
31044 }
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31048
31049 wxPyEndAllowThreads(__tstate);
31050 if (PyErr_Occurred()) SWIG_fail;
31051 }
31052 Py_INCREF(Py_None); resultobj = Py_None;
31053 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31054 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31055 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31056 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31057 return resultobj;
31058 fail:
31059 return NULL;
31060 }
31061
31062
31063 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31064 PyObject *resultobj;
31065 wxWindow *arg1 = (wxWindow *) 0 ;
31066 int *arg2 = (int *) 0 ;
31067 int *arg3 = (int *) 0 ;
31068 int temp2 ;
31069 int res2 = 0 ;
31070 int temp3 ;
31071 int res3 = 0 ;
31072 PyObject * obj0 = 0 ;
31073 PyObject * obj1 = 0 ;
31074 PyObject * obj2 = 0 ;
31075 char *kwnames[] = {
31076 (char *) "self",(char *) "x",(char *) "y", NULL
31077 };
31078
31079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31081 if (SWIG_arg_fail(1)) SWIG_fail;
31082 {
31083 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31084 temp2 = SWIG_As_int(obj1);
31085 if (SWIG_arg_fail(2)) SWIG_fail;
31086 arg2 = &temp2;
31087 res2 = SWIG_NEWOBJ;
31088 }
31089 }
31090 {
31091 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31092 temp3 = SWIG_As_int(obj2);
31093 if (SWIG_arg_fail(3)) SWIG_fail;
31094 arg3 = &temp3;
31095 res3 = SWIG_NEWOBJ;
31096 }
31097 }
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 Py_INCREF(Py_None); resultobj = Py_None;
31106 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31107 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31108 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31109 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxPoint *arg2 = 0 ;
31120 wxPoint result;
31121 wxPoint temp2 ;
31122 PyObject * obj0 = 0 ;
31123 PyObject * obj1 = 0 ;
31124 char *kwnames[] = {
31125 (char *) "self",(char *) "pt", NULL
31126 };
31127
31128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31130 if (SWIG_arg_fail(1)) SWIG_fail;
31131 {
31132 arg2 = &temp2;
31133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31134 }
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 {
31143 wxPoint * resultptr;
31144 resultptr = new wxPoint((wxPoint &)(result));
31145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31146 }
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31154 PyObject *resultobj;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 wxPoint *arg2 = 0 ;
31157 wxPoint result;
31158 wxPoint temp2 ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 char *kwnames[] = {
31162 (char *) "self",(char *) "pt", NULL
31163 };
31164
31165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31167 if (SWIG_arg_fail(1)) SWIG_fail;
31168 {
31169 arg2 = &temp2;
31170 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31171 }
31172 {
31173 PyThreadState* __tstate = wxPyBeginAllowThreads();
31174 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31175
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 {
31180 wxPoint * resultptr;
31181 resultptr = new wxPoint((wxPoint &)(result));
31182 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31183 }
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj;
31192 wxWindow *arg1 = (wxWindow *) 0 ;
31193 int arg2 ;
31194 int arg3 ;
31195 wxHitTest result;
31196 PyObject * obj0 = 0 ;
31197 PyObject * obj1 = 0 ;
31198 PyObject * obj2 = 0 ;
31199 char *kwnames[] = {
31200 (char *) "self",(char *) "x",(char *) "y", NULL
31201 };
31202
31203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31205 if (SWIG_arg_fail(1)) SWIG_fail;
31206 {
31207 arg2 = (int)(SWIG_As_int(obj1));
31208 if (SWIG_arg_fail(2)) SWIG_fail;
31209 }
31210 {
31211 arg3 = (int)(SWIG_As_int(obj2));
31212 if (SWIG_arg_fail(3)) SWIG_fail;
31213 }
31214 {
31215 PyThreadState* __tstate = wxPyBeginAllowThreads();
31216 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31217
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_From_int((result));
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj;
31230 wxWindow *arg1 = (wxWindow *) 0 ;
31231 wxPoint *arg2 = 0 ;
31232 wxHitTest result;
31233 wxPoint temp2 ;
31234 PyObject * obj0 = 0 ;
31235 PyObject * obj1 = 0 ;
31236 char *kwnames[] = {
31237 (char *) "self",(char *) "pt", NULL
31238 };
31239
31240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31242 if (SWIG_arg_fail(1)) SWIG_fail;
31243 {
31244 arg2 = &temp2;
31245 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31246 }
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31250
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 resultobj = SWIG_From_int((result));
31255 return resultobj;
31256 fail:
31257 return NULL;
31258 }
31259
31260
31261 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31262 PyObject *resultobj;
31263 wxWindow *arg1 = (wxWindow *) 0 ;
31264 long arg2 ;
31265 wxBorder result;
31266 PyObject * obj0 = 0 ;
31267 PyObject * obj1 = 0 ;
31268
31269 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 arg2 = (long)(SWIG_As_long(obj1));
31274 if (SWIG_arg_fail(2)) SWIG_fail;
31275 }
31276 {
31277 PyThreadState* __tstate = wxPyBeginAllowThreads();
31278 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31279
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_From_int((result));
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31291 PyObject *resultobj;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 wxBorder result;
31294 PyObject * obj0 = 0 ;
31295
31296 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31298 if (SWIG_arg_fail(1)) SWIG_fail;
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31302
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_From_int((result));
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31314 int argc;
31315 PyObject *argv[3];
31316 int ii;
31317
31318 argc = PyObject_Length(args);
31319 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31320 argv[ii] = PyTuple_GetItem(args,ii);
31321 }
31322 if (argc == 1) {
31323 int _v;
31324 {
31325 void *ptr;
31326 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31327 _v = 0;
31328 PyErr_Clear();
31329 } else {
31330 _v = 1;
31331 }
31332 }
31333 if (_v) {
31334 return _wrap_Window_GetBorder__SWIG_1(self,args);
31335 }
31336 }
31337 if (argc == 2) {
31338 int _v;
31339 {
31340 void *ptr;
31341 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31342 _v = 0;
31343 PyErr_Clear();
31344 } else {
31345 _v = 1;
31346 }
31347 }
31348 if (_v) {
31349 _v = SWIG_Check_long(argv[1]);
31350 if (_v) {
31351 return _wrap_Window_GetBorder__SWIG_0(self,args);
31352 }
31353 }
31354 }
31355
31356 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31357 return NULL;
31358 }
31359
31360
31361 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 long arg2 = (long) wxUPDATE_UI_NONE ;
31365 PyObject * obj0 = 0 ;
31366 PyObject * obj1 = 0 ;
31367 char *kwnames[] = {
31368 (char *) "self",(char *) "flags", NULL
31369 };
31370
31371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31373 if (SWIG_arg_fail(1)) SWIG_fail;
31374 if (obj1) {
31375 {
31376 arg2 = (long)(SWIG_As_long(obj1));
31377 if (SWIG_arg_fail(2)) SWIG_fail;
31378 }
31379 }
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 (arg1)->UpdateWindowUI(arg2);
31383
31384 wxPyEndAllowThreads(__tstate);
31385 if (PyErr_Occurred()) SWIG_fail;
31386 }
31387 Py_INCREF(Py_None); resultobj = Py_None;
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 wxMenu *arg2 = (wxMenu *) 0 ;
31398 int arg3 = (int) -1 ;
31399 int arg4 = (int) -1 ;
31400 bool result;
31401 PyObject * obj0 = 0 ;
31402 PyObject * obj1 = 0 ;
31403 PyObject * obj2 = 0 ;
31404 PyObject * obj3 = 0 ;
31405 char *kwnames[] = {
31406 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31407 };
31408
31409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31411 if (SWIG_arg_fail(1)) SWIG_fail;
31412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31413 if (SWIG_arg_fail(2)) SWIG_fail;
31414 if (obj2) {
31415 {
31416 arg3 = (int)(SWIG_As_int(obj2));
31417 if (SWIG_arg_fail(3)) SWIG_fail;
31418 }
31419 }
31420 if (obj3) {
31421 {
31422 arg4 = (int)(SWIG_As_int(obj3));
31423 if (SWIG_arg_fail(4)) SWIG_fail;
31424 }
31425 }
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31429
31430 wxPyEndAllowThreads(__tstate);
31431 if (PyErr_Occurred()) SWIG_fail;
31432 }
31433 {
31434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31435 }
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31443 PyObject *resultobj;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 wxMenu *arg2 = (wxMenu *) 0 ;
31446 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31447 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31448 bool result;
31449 wxPoint temp3 ;
31450 PyObject * obj0 = 0 ;
31451 PyObject * obj1 = 0 ;
31452 PyObject * obj2 = 0 ;
31453 char *kwnames[] = {
31454 (char *) "self",(char *) "menu",(char *) "pos", NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31459 if (SWIG_arg_fail(1)) SWIG_fail;
31460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(2)) SWIG_fail;
31462 if (obj2) {
31463 {
31464 arg3 = &temp3;
31465 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31466 }
31467 }
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31471
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 {
31476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31477 }
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 long result;
31488 PyObject * obj0 = 0 ;
31489 char *kwnames[] = {
31490 (char *) "self", NULL
31491 };
31492
31493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31495 if (SWIG_arg_fail(1)) SWIG_fail;
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (long)wxWindow_GetHandle(arg1);
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 resultobj = SWIG_From_long((long)(result));
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxWindow *arg1 = (wxWindow *) 0 ;
31515 long arg2 ;
31516 PyObject * obj0 = 0 ;
31517 PyObject * obj1 = 0 ;
31518 char *kwnames[] = {
31519 (char *) "self",(char *) "handle", NULL
31520 };
31521
31522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31524 if (SWIG_arg_fail(1)) SWIG_fail;
31525 {
31526 arg2 = (long)(SWIG_As_long(obj1));
31527 if (SWIG_arg_fail(2)) SWIG_fail;
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 wxWindow_AssociateHandle(arg1,arg2);
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 Py_INCREF(Py_None); resultobj = Py_None;
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 PyObject * obj0 = 0 ;
31547 char *kwnames[] = {
31548 (char *) "self", NULL
31549 };
31550
31551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31553 if (SWIG_arg_fail(1)) SWIG_fail;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 (arg1)->DissociateHandle();
31557
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 Py_INCREF(Py_None); resultobj = Py_None;
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31569 PyObject *resultobj;
31570 wxWindow *arg1 = (wxWindow *) 0 ;
31571 int arg2 ;
31572 bool result;
31573 PyObject * obj0 = 0 ;
31574 PyObject * obj1 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "self",(char *) "orient", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31581 if (SWIG_arg_fail(1)) SWIG_fail;
31582 {
31583 arg2 = (int)(SWIG_As_int(obj1));
31584 if (SWIG_arg_fail(2)) SWIG_fail;
31585 }
31586 {
31587 PyThreadState* __tstate = wxPyBeginAllowThreads();
31588 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31589
31590 wxPyEndAllowThreads(__tstate);
31591 if (PyErr_Occurred()) SWIG_fail;
31592 }
31593 {
31594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31595 }
31596 return resultobj;
31597 fail:
31598 return NULL;
31599 }
31600
31601
31602 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31603 PyObject *resultobj;
31604 wxWindow *arg1 = (wxWindow *) 0 ;
31605 int arg2 ;
31606 int arg3 ;
31607 int arg4 ;
31608 int arg5 ;
31609 bool arg6 = (bool) true ;
31610 PyObject * obj0 = 0 ;
31611 PyObject * obj1 = 0 ;
31612 PyObject * obj2 = 0 ;
31613 PyObject * obj3 = 0 ;
31614 PyObject * obj4 = 0 ;
31615 PyObject * obj5 = 0 ;
31616 char *kwnames[] = {
31617 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31618 };
31619
31620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31622 if (SWIG_arg_fail(1)) SWIG_fail;
31623 {
31624 arg2 = (int)(SWIG_As_int(obj1));
31625 if (SWIG_arg_fail(2)) SWIG_fail;
31626 }
31627 {
31628 arg3 = (int)(SWIG_As_int(obj2));
31629 if (SWIG_arg_fail(3)) SWIG_fail;
31630 }
31631 {
31632 arg4 = (int)(SWIG_As_int(obj3));
31633 if (SWIG_arg_fail(4)) SWIG_fail;
31634 }
31635 {
31636 arg5 = (int)(SWIG_As_int(obj4));
31637 if (SWIG_arg_fail(5)) SWIG_fail;
31638 }
31639 if (obj5) {
31640 {
31641 arg6 = (bool)(SWIG_As_bool(obj5));
31642 if (SWIG_arg_fail(6)) SWIG_fail;
31643 }
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31648
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 Py_INCREF(Py_None); resultobj = Py_None;
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31660 PyObject *resultobj;
31661 wxWindow *arg1 = (wxWindow *) 0 ;
31662 int arg2 ;
31663 int arg3 ;
31664 bool arg4 = (bool) true ;
31665 PyObject * obj0 = 0 ;
31666 PyObject * obj1 = 0 ;
31667 PyObject * obj2 = 0 ;
31668 PyObject * obj3 = 0 ;
31669 char *kwnames[] = {
31670 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31671 };
31672
31673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31675 if (SWIG_arg_fail(1)) SWIG_fail;
31676 {
31677 arg2 = (int)(SWIG_As_int(obj1));
31678 if (SWIG_arg_fail(2)) SWIG_fail;
31679 }
31680 {
31681 arg3 = (int)(SWIG_As_int(obj2));
31682 if (SWIG_arg_fail(3)) SWIG_fail;
31683 }
31684 if (obj3) {
31685 {
31686 arg4 = (bool)(SWIG_As_bool(obj3));
31687 if (SWIG_arg_fail(4)) SWIG_fail;
31688 }
31689 }
31690 {
31691 PyThreadState* __tstate = wxPyBeginAllowThreads();
31692 (arg1)->SetScrollPos(arg2,arg3,arg4);
31693
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 Py_INCREF(Py_None); resultobj = Py_None;
31698 return resultobj;
31699 fail:
31700 return NULL;
31701 }
31702
31703
31704 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31705 PyObject *resultobj;
31706 wxWindow *arg1 = (wxWindow *) 0 ;
31707 int arg2 ;
31708 int result;
31709 PyObject * obj0 = 0 ;
31710 PyObject * obj1 = 0 ;
31711 char *kwnames[] = {
31712 (char *) "self",(char *) "orientation", NULL
31713 };
31714
31715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31717 if (SWIG_arg_fail(1)) SWIG_fail;
31718 {
31719 arg2 = (int)(SWIG_As_int(obj1));
31720 if (SWIG_arg_fail(2)) SWIG_fail;
31721 }
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31725
31726 wxPyEndAllowThreads(__tstate);
31727 if (PyErr_Occurred()) SWIG_fail;
31728 }
31729 {
31730 resultobj = SWIG_From_int((int)(result));
31731 }
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj;
31740 wxWindow *arg1 = (wxWindow *) 0 ;
31741 int arg2 ;
31742 int result;
31743 PyObject * obj0 = 0 ;
31744 PyObject * obj1 = 0 ;
31745 char *kwnames[] = {
31746 (char *) "self",(char *) "orientation", NULL
31747 };
31748
31749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31751 if (SWIG_arg_fail(1)) SWIG_fail;
31752 {
31753 arg2 = (int)(SWIG_As_int(obj1));
31754 if (SWIG_arg_fail(2)) SWIG_fail;
31755 }
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31759
31760 wxPyEndAllowThreads(__tstate);
31761 if (PyErr_Occurred()) SWIG_fail;
31762 }
31763 {
31764 resultobj = SWIG_From_int((int)(result));
31765 }
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31773 PyObject *resultobj;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 int arg2 ;
31776 int result;
31777 PyObject * obj0 = 0 ;
31778 PyObject * obj1 = 0 ;
31779 char *kwnames[] = {
31780 (char *) "self",(char *) "orientation", NULL
31781 };
31782
31783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31785 if (SWIG_arg_fail(1)) SWIG_fail;
31786 {
31787 arg2 = (int)(SWIG_As_int(obj1));
31788 if (SWIG_arg_fail(2)) SWIG_fail;
31789 }
31790 {
31791 PyThreadState* __tstate = wxPyBeginAllowThreads();
31792 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31793
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 {
31798 resultobj = SWIG_From_int((int)(result));
31799 }
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31807 PyObject *resultobj;
31808 wxWindow *arg1 = (wxWindow *) 0 ;
31809 int arg2 ;
31810 int arg3 ;
31811 wxRect *arg4 = (wxRect *) NULL ;
31812 PyObject * obj0 = 0 ;
31813 PyObject * obj1 = 0 ;
31814 PyObject * obj2 = 0 ;
31815 PyObject * obj3 = 0 ;
31816 char *kwnames[] = {
31817 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31818 };
31819
31820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31822 if (SWIG_arg_fail(1)) SWIG_fail;
31823 {
31824 arg2 = (int)(SWIG_As_int(obj1));
31825 if (SWIG_arg_fail(2)) SWIG_fail;
31826 }
31827 {
31828 arg3 = (int)(SWIG_As_int(obj2));
31829 if (SWIG_arg_fail(3)) SWIG_fail;
31830 }
31831 if (obj3) {
31832 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31833 if (SWIG_arg_fail(4)) SWIG_fail;
31834 }
31835 {
31836 PyThreadState* __tstate = wxPyBeginAllowThreads();
31837 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31838
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 Py_INCREF(Py_None); resultobj = Py_None;
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj;
31851 wxWindow *arg1 = (wxWindow *) 0 ;
31852 int arg2 ;
31853 bool result;
31854 PyObject * obj0 = 0 ;
31855 PyObject * obj1 = 0 ;
31856 char *kwnames[] = {
31857 (char *) "self",(char *) "lines", NULL
31858 };
31859
31860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31862 if (SWIG_arg_fail(1)) SWIG_fail;
31863 {
31864 arg2 = (int)(SWIG_As_int(obj1));
31865 if (SWIG_arg_fail(2)) SWIG_fail;
31866 }
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (bool)(arg1)->ScrollLines(arg2);
31870
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 {
31875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31876 }
31877 return resultobj;
31878 fail:
31879 return NULL;
31880 }
31881
31882
31883 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31884 PyObject *resultobj;
31885 wxWindow *arg1 = (wxWindow *) 0 ;
31886 int arg2 ;
31887 bool result;
31888 PyObject * obj0 = 0 ;
31889 PyObject * obj1 = 0 ;
31890 char *kwnames[] = {
31891 (char *) "self",(char *) "pages", NULL
31892 };
31893
31894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31896 if (SWIG_arg_fail(1)) SWIG_fail;
31897 {
31898 arg2 = (int)(SWIG_As_int(obj1));
31899 if (SWIG_arg_fail(2)) SWIG_fail;
31900 }
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 result = (bool)(arg1)->ScrollPages(arg2);
31904
31905 wxPyEndAllowThreads(__tstate);
31906 if (PyErr_Occurred()) SWIG_fail;
31907 }
31908 {
31909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31910 }
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 bool result;
31921 PyObject * obj0 = 0 ;
31922 char *kwnames[] = {
31923 (char *) "self", NULL
31924 };
31925
31926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31928 if (SWIG_arg_fail(1)) SWIG_fail;
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 result = (bool)(arg1)->LineUp();
31932
31933 wxPyEndAllowThreads(__tstate);
31934 if (PyErr_Occurred()) SWIG_fail;
31935 }
31936 {
31937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31938 }
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31946 PyObject *resultobj;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 bool result;
31949 PyObject * obj0 = 0 ;
31950 char *kwnames[] = {
31951 (char *) "self", NULL
31952 };
31953
31954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31956 if (SWIG_arg_fail(1)) SWIG_fail;
31957 {
31958 PyThreadState* __tstate = wxPyBeginAllowThreads();
31959 result = (bool)(arg1)->LineDown();
31960
31961 wxPyEndAllowThreads(__tstate);
31962 if (PyErr_Occurred()) SWIG_fail;
31963 }
31964 {
31965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31966 }
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 bool result;
31977 PyObject * obj0 = 0 ;
31978 char *kwnames[] = {
31979 (char *) "self", NULL
31980 };
31981
31982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(1)) SWIG_fail;
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 result = (bool)(arg1)->PageUp();
31988
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 {
31993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31994 }
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj;
32003 wxWindow *arg1 = (wxWindow *) 0 ;
32004 bool result;
32005 PyObject * obj0 = 0 ;
32006 char *kwnames[] = {
32007 (char *) "self", NULL
32008 };
32009
32010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32012 if (SWIG_arg_fail(1)) SWIG_fail;
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (bool)(arg1)->PageDown();
32016
32017 wxPyEndAllowThreads(__tstate);
32018 if (PyErr_Occurred()) SWIG_fail;
32019 }
32020 {
32021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32022 }
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32030 PyObject *resultobj;
32031 wxWindow *arg1 = (wxWindow *) 0 ;
32032 wxString *arg2 = 0 ;
32033 bool temp2 = false ;
32034 PyObject * obj0 = 0 ;
32035 PyObject * obj1 = 0 ;
32036 char *kwnames[] = {
32037 (char *) "self",(char *) "text", NULL
32038 };
32039
32040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32042 if (SWIG_arg_fail(1)) SWIG_fail;
32043 {
32044 arg2 = wxString_in_helper(obj1);
32045 if (arg2 == NULL) SWIG_fail;
32046 temp2 = true;
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 (arg1)->SetHelpText((wxString const &)*arg2);
32051
32052 wxPyEndAllowThreads(__tstate);
32053 if (PyErr_Occurred()) SWIG_fail;
32054 }
32055 Py_INCREF(Py_None); resultobj = Py_None;
32056 {
32057 if (temp2)
32058 delete arg2;
32059 }
32060 return resultobj;
32061 fail:
32062 {
32063 if (temp2)
32064 delete arg2;
32065 }
32066 return NULL;
32067 }
32068
32069
32070 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32071 PyObject *resultobj;
32072 wxWindow *arg1 = (wxWindow *) 0 ;
32073 wxString *arg2 = 0 ;
32074 bool temp2 = false ;
32075 PyObject * obj0 = 0 ;
32076 PyObject * obj1 = 0 ;
32077 char *kwnames[] = {
32078 (char *) "self",(char *) "text", NULL
32079 };
32080
32081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32083 if (SWIG_arg_fail(1)) SWIG_fail;
32084 {
32085 arg2 = wxString_in_helper(obj1);
32086 if (arg2 == NULL) SWIG_fail;
32087 temp2 = true;
32088 }
32089 {
32090 PyThreadState* __tstate = wxPyBeginAllowThreads();
32091 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32092
32093 wxPyEndAllowThreads(__tstate);
32094 if (PyErr_Occurred()) SWIG_fail;
32095 }
32096 Py_INCREF(Py_None); resultobj = Py_None;
32097 {
32098 if (temp2)
32099 delete arg2;
32100 }
32101 return resultobj;
32102 fail:
32103 {
32104 if (temp2)
32105 delete arg2;
32106 }
32107 return NULL;
32108 }
32109
32110
32111 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32112 PyObject *resultobj;
32113 wxWindow *arg1 = (wxWindow *) 0 ;
32114 wxString result;
32115 PyObject * obj0 = 0 ;
32116 char *kwnames[] = {
32117 (char *) "self", NULL
32118 };
32119
32120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32122 if (SWIG_arg_fail(1)) SWIG_fail;
32123 {
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = ((wxWindow const *)arg1)->GetHelpText();
32126
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 {
32131 #if wxUSE_UNICODE
32132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32133 #else
32134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32135 #endif
32136 }
32137 return resultobj;
32138 fail:
32139 return NULL;
32140 }
32141
32142
32143 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32144 PyObject *resultobj;
32145 wxWindow *arg1 = (wxWindow *) 0 ;
32146 wxString *arg2 = 0 ;
32147 bool temp2 = false ;
32148 PyObject * obj0 = 0 ;
32149 PyObject * obj1 = 0 ;
32150 char *kwnames[] = {
32151 (char *) "self",(char *) "tip", NULL
32152 };
32153
32154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32156 if (SWIG_arg_fail(1)) SWIG_fail;
32157 {
32158 arg2 = wxString_in_helper(obj1);
32159 if (arg2 == NULL) SWIG_fail;
32160 temp2 = true;
32161 }
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 (arg1)->SetToolTip((wxString const &)*arg2);
32165
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 Py_INCREF(Py_None); resultobj = Py_None;
32170 {
32171 if (temp2)
32172 delete arg2;
32173 }
32174 return resultobj;
32175 fail:
32176 {
32177 if (temp2)
32178 delete arg2;
32179 }
32180 return NULL;
32181 }
32182
32183
32184 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32185 PyObject *resultobj;
32186 wxWindow *arg1 = (wxWindow *) 0 ;
32187 wxToolTip *arg2 = (wxToolTip *) 0 ;
32188 PyObject * obj0 = 0 ;
32189 PyObject * obj1 = 0 ;
32190 char *kwnames[] = {
32191 (char *) "self",(char *) "tip", NULL
32192 };
32193
32194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32196 if (SWIG_arg_fail(1)) SWIG_fail;
32197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32198 if (SWIG_arg_fail(2)) SWIG_fail;
32199 {
32200 PyThreadState* __tstate = wxPyBeginAllowThreads();
32201 (arg1)->SetToolTip(arg2);
32202
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 Py_INCREF(Py_None); resultobj = Py_None;
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj;
32215 wxWindow *arg1 = (wxWindow *) 0 ;
32216 wxToolTip *result;
32217 PyObject * obj0 = 0 ;
32218 char *kwnames[] = {
32219 (char *) "self", NULL
32220 };
32221
32222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32224 if (SWIG_arg_fail(1)) SWIG_fail;
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32228
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 {
32233 resultobj = wxPyMake_wxObject(result, 0);
32234 }
32235 return resultobj;
32236 fail:
32237 return NULL;
32238 }
32239
32240
32241 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32242 PyObject *resultobj;
32243 wxWindow *arg1 = (wxWindow *) 0 ;
32244 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char *kwnames[] = {
32248 (char *) "self",(char *) "dropTarget", NULL
32249 };
32250
32251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32253 if (SWIG_arg_fail(1)) SWIG_fail;
32254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32255 if (SWIG_arg_fail(2)) SWIG_fail;
32256 {
32257 PyThreadState* __tstate = wxPyBeginAllowThreads();
32258 (arg1)->SetDropTarget(arg2);
32259
32260 wxPyEndAllowThreads(__tstate);
32261 if (PyErr_Occurred()) SWIG_fail;
32262 }
32263 Py_INCREF(Py_None); resultobj = Py_None;
32264 return resultobj;
32265 fail:
32266 return NULL;
32267 }
32268
32269
32270 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32271 PyObject *resultobj;
32272 wxWindow *arg1 = (wxWindow *) 0 ;
32273 wxPyDropTarget *result;
32274 PyObject * obj0 = 0 ;
32275 char *kwnames[] = {
32276 (char *) "self", NULL
32277 };
32278
32279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 {
32283 PyThreadState* __tstate = wxPyBeginAllowThreads();
32284 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32285
32286 wxPyEndAllowThreads(__tstate);
32287 if (PyErr_Occurred()) SWIG_fail;
32288 }
32289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32290 return resultobj;
32291 fail:
32292 return NULL;
32293 }
32294
32295
32296 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32297 PyObject *resultobj;
32298 wxWindow *arg1 = (wxWindow *) 0 ;
32299 bool arg2 ;
32300 PyObject * obj0 = 0 ;
32301 PyObject * obj1 = 0 ;
32302 char *kwnames[] = {
32303 (char *) "self",(char *) "accept", NULL
32304 };
32305
32306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32308 if (SWIG_arg_fail(1)) SWIG_fail;
32309 {
32310 arg2 = (bool)(SWIG_As_bool(obj1));
32311 if (SWIG_arg_fail(2)) SWIG_fail;
32312 }
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 wxWindow_DragAcceptFiles(arg1,arg2);
32316
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 Py_INCREF(Py_None); resultobj = Py_None;
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj;
32329 wxWindow *arg1 = (wxWindow *) 0 ;
32330 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32331 PyObject * obj0 = 0 ;
32332 PyObject * obj1 = 0 ;
32333 char *kwnames[] = {
32334 (char *) "self",(char *) "constraints", NULL
32335 };
32336
32337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32339 if (SWIG_arg_fail(1)) SWIG_fail;
32340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32341 if (SWIG_arg_fail(2)) SWIG_fail;
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 (arg1)->SetConstraints(arg2);
32345
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 Py_INCREF(Py_None); resultobj = Py_None;
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj;
32358 wxWindow *arg1 = (wxWindow *) 0 ;
32359 wxLayoutConstraints *result;
32360 PyObject * obj0 = 0 ;
32361 char *kwnames[] = {
32362 (char *) "self", NULL
32363 };
32364
32365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32367 if (SWIG_arg_fail(1)) SWIG_fail;
32368 {
32369 PyThreadState* __tstate = wxPyBeginAllowThreads();
32370 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32371
32372 wxPyEndAllowThreads(__tstate);
32373 if (PyErr_Occurred()) SWIG_fail;
32374 }
32375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32376 return resultobj;
32377 fail:
32378 return NULL;
32379 }
32380
32381
32382 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32383 PyObject *resultobj;
32384 wxWindow *arg1 = (wxWindow *) 0 ;
32385 bool arg2 ;
32386 PyObject * obj0 = 0 ;
32387 PyObject * obj1 = 0 ;
32388 char *kwnames[] = {
32389 (char *) "self",(char *) "autoLayout", NULL
32390 };
32391
32392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32394 if (SWIG_arg_fail(1)) SWIG_fail;
32395 {
32396 arg2 = (bool)(SWIG_As_bool(obj1));
32397 if (SWIG_arg_fail(2)) SWIG_fail;
32398 }
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 (arg1)->SetAutoLayout(arg2);
32402
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 Py_INCREF(Py_None); resultobj = Py_None;
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj;
32415 wxWindow *arg1 = (wxWindow *) 0 ;
32416 bool result;
32417 PyObject * obj0 = 0 ;
32418 char *kwnames[] = {
32419 (char *) "self", NULL
32420 };
32421
32422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32424 if (SWIG_arg_fail(1)) SWIG_fail;
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32428
32429 wxPyEndAllowThreads(__tstate);
32430 if (PyErr_Occurred()) SWIG_fail;
32431 }
32432 {
32433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 bool result;
32445 PyObject * obj0 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "self", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32452 if (SWIG_arg_fail(1)) SWIG_fail;
32453 {
32454 PyThreadState* __tstate = wxPyBeginAllowThreads();
32455 result = (bool)(arg1)->Layout();
32456
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 {
32461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 wxSizer *arg2 = (wxSizer *) 0 ;
32473 bool arg3 = (bool) true ;
32474 PyObject * obj0 = 0 ;
32475 PyObject * obj1 = 0 ;
32476 PyObject * obj2 = 0 ;
32477 char *kwnames[] = {
32478 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32479 };
32480
32481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32483 if (SWIG_arg_fail(1)) SWIG_fail;
32484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32485 if (SWIG_arg_fail(2)) SWIG_fail;
32486 if (obj2) {
32487 {
32488 arg3 = (bool)(SWIG_As_bool(obj2));
32489 if (SWIG_arg_fail(3)) SWIG_fail;
32490 }
32491 }
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 (arg1)->SetSizer(arg2,arg3);
32495
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 Py_INCREF(Py_None); resultobj = Py_None;
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32507 PyObject *resultobj;
32508 wxWindow *arg1 = (wxWindow *) 0 ;
32509 wxSizer *arg2 = (wxSizer *) 0 ;
32510 bool arg3 = (bool) true ;
32511 PyObject * obj0 = 0 ;
32512 PyObject * obj1 = 0 ;
32513 PyObject * obj2 = 0 ;
32514 char *kwnames[] = {
32515 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32516 };
32517
32518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32520 if (SWIG_arg_fail(1)) SWIG_fail;
32521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32522 if (SWIG_arg_fail(2)) SWIG_fail;
32523 if (obj2) {
32524 {
32525 arg3 = (bool)(SWIG_As_bool(obj2));
32526 if (SWIG_arg_fail(3)) SWIG_fail;
32527 }
32528 }
32529 {
32530 PyThreadState* __tstate = wxPyBeginAllowThreads();
32531 (arg1)->SetSizerAndFit(arg2,arg3);
32532
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 Py_INCREF(Py_None); resultobj = Py_None;
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 wxWindow *arg1 = (wxWindow *) 0 ;
32546 wxSizer *result;
32547 PyObject * obj0 = 0 ;
32548 char *kwnames[] = {
32549 (char *) "self", NULL
32550 };
32551
32552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32554 if (SWIG_arg_fail(1)) SWIG_fail;
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32558
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 {
32563 resultobj = wxPyMake_wxObject(result, 0);
32564 }
32565 return resultobj;
32566 fail:
32567 return NULL;
32568 }
32569
32570
32571 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32572 PyObject *resultobj;
32573 wxWindow *arg1 = (wxWindow *) 0 ;
32574 wxSizer *arg2 = (wxSizer *) 0 ;
32575 PyObject * obj0 = 0 ;
32576 PyObject * obj1 = 0 ;
32577 char *kwnames[] = {
32578 (char *) "self",(char *) "sizer", NULL
32579 };
32580
32581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32583 if (SWIG_arg_fail(1)) SWIG_fail;
32584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32585 if (SWIG_arg_fail(2)) SWIG_fail;
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 (arg1)->SetContainingSizer(arg2);
32589
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 Py_INCREF(Py_None); resultobj = Py_None;
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32601 PyObject *resultobj;
32602 wxWindow *arg1 = (wxWindow *) 0 ;
32603 wxSizer *result;
32604 PyObject * obj0 = 0 ;
32605 char *kwnames[] = {
32606 (char *) "self", NULL
32607 };
32608
32609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32611 if (SWIG_arg_fail(1)) SWIG_fail;
32612 {
32613 PyThreadState* __tstate = wxPyBeginAllowThreads();
32614 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32615
32616 wxPyEndAllowThreads(__tstate);
32617 if (PyErr_Occurred()) SWIG_fail;
32618 }
32619 {
32620 resultobj = wxPyMake_wxObject(result, 0);
32621 }
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj;
32630 wxWindow *arg1 = (wxWindow *) 0 ;
32631 PyObject * obj0 = 0 ;
32632 char *kwnames[] = {
32633 (char *) "self", NULL
32634 };
32635
32636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32638 if (SWIG_arg_fail(1)) SWIG_fail;
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 (arg1)->InheritAttributes();
32642
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 Py_INCREF(Py_None); resultobj = Py_None;
32647 return resultobj;
32648 fail:
32649 return NULL;
32650 }
32651
32652
32653 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32654 PyObject *resultobj;
32655 wxWindow *arg1 = (wxWindow *) 0 ;
32656 bool result;
32657 PyObject * obj0 = 0 ;
32658 char *kwnames[] = {
32659 (char *) "self", NULL
32660 };
32661
32662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32664 if (SWIG_arg_fail(1)) SWIG_fail;
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32668
32669 wxPyEndAllowThreads(__tstate);
32670 if (PyErr_Occurred()) SWIG_fail;
32671 }
32672 {
32673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32674 }
32675 return resultobj;
32676 fail:
32677 return NULL;
32678 }
32679
32680
32681 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32682 PyObject *obj;
32683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32684 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32685 Py_INCREF(obj);
32686 return Py_BuildValue((char *)"");
32687 }
32688 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32689 PyObject *resultobj;
32690 long arg1 ;
32691 wxWindow *arg2 = (wxWindow *) NULL ;
32692 wxWindow *result;
32693 PyObject * obj0 = 0 ;
32694 PyObject * obj1 = 0 ;
32695 char *kwnames[] = {
32696 (char *) "id",(char *) "parent", NULL
32697 };
32698
32699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32700 {
32701 arg1 = (long)(SWIG_As_long(obj0));
32702 if (SWIG_arg_fail(1)) SWIG_fail;
32703 }
32704 if (obj1) {
32705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32706 if (SWIG_arg_fail(2)) SWIG_fail;
32707 }
32708 {
32709 if (!wxPyCheckForApp()) SWIG_fail;
32710 PyThreadState* __tstate = wxPyBeginAllowThreads();
32711 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32712
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 {
32717 resultobj = wxPyMake_wxObject(result, 0);
32718 }
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj;
32727 wxString *arg1 = 0 ;
32728 wxWindow *arg2 = (wxWindow *) NULL ;
32729 wxWindow *result;
32730 bool temp1 = false ;
32731 PyObject * obj0 = 0 ;
32732 PyObject * obj1 = 0 ;
32733 char *kwnames[] = {
32734 (char *) "name",(char *) "parent", NULL
32735 };
32736
32737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32738 {
32739 arg1 = wxString_in_helper(obj0);
32740 if (arg1 == NULL) SWIG_fail;
32741 temp1 = true;
32742 }
32743 if (obj1) {
32744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32745 if (SWIG_arg_fail(2)) SWIG_fail;
32746 }
32747 {
32748 if (!wxPyCheckForApp()) SWIG_fail;
32749 PyThreadState* __tstate = wxPyBeginAllowThreads();
32750 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32751
32752 wxPyEndAllowThreads(__tstate);
32753 if (PyErr_Occurred()) SWIG_fail;
32754 }
32755 {
32756 resultobj = wxPyMake_wxObject(result, 0);
32757 }
32758 {
32759 if (temp1)
32760 delete arg1;
32761 }
32762 return resultobj;
32763 fail:
32764 {
32765 if (temp1)
32766 delete arg1;
32767 }
32768 return NULL;
32769 }
32770
32771
32772 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32773 PyObject *resultobj;
32774 wxString *arg1 = 0 ;
32775 wxWindow *arg2 = (wxWindow *) NULL ;
32776 wxWindow *result;
32777 bool temp1 = false ;
32778 PyObject * obj0 = 0 ;
32779 PyObject * obj1 = 0 ;
32780 char *kwnames[] = {
32781 (char *) "label",(char *) "parent", NULL
32782 };
32783
32784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32785 {
32786 arg1 = wxString_in_helper(obj0);
32787 if (arg1 == NULL) SWIG_fail;
32788 temp1 = true;
32789 }
32790 if (obj1) {
32791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32792 if (SWIG_arg_fail(2)) SWIG_fail;
32793 }
32794 {
32795 if (!wxPyCheckForApp()) SWIG_fail;
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32798
32799 wxPyEndAllowThreads(__tstate);
32800 if (PyErr_Occurred()) SWIG_fail;
32801 }
32802 {
32803 resultobj = wxPyMake_wxObject(result, 0);
32804 }
32805 {
32806 if (temp1)
32807 delete arg1;
32808 }
32809 return resultobj;
32810 fail:
32811 {
32812 if (temp1)
32813 delete arg1;
32814 }
32815 return NULL;
32816 }
32817
32818
32819 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32820 PyObject *resultobj;
32821 wxWindow *arg1 = (wxWindow *) 0 ;
32822 unsigned long arg2 ;
32823 wxWindow *result;
32824 PyObject * obj0 = 0 ;
32825 PyObject * obj1 = 0 ;
32826 char *kwnames[] = {
32827 (char *) "parent",(char *) "_hWnd", NULL
32828 };
32829
32830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32832 if (SWIG_arg_fail(1)) SWIG_fail;
32833 {
32834 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32835 if (SWIG_arg_fail(2)) SWIG_fail;
32836 }
32837 {
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32840
32841 wxPyEndAllowThreads(__tstate);
32842 if (PyErr_Occurred()) SWIG_fail;
32843 }
32844 {
32845 resultobj = wxPyMake_wxObject(result, 0);
32846 }
32847 return resultobj;
32848 fail:
32849 return NULL;
32850 }
32851
32852
32853 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32854 PyObject *resultobj;
32855 PyObject *result;
32856 char *kwnames[] = {
32857 NULL
32858 };
32859
32860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32861 {
32862 PyThreadState* __tstate = wxPyBeginAllowThreads();
32863 result = (PyObject *)GetTopLevelWindows();
32864
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 resultobj = result;
32869 return resultobj;
32870 fail:
32871 return NULL;
32872 }
32873
32874
32875 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32876 PyObject *resultobj;
32877 wxValidator *result;
32878 char *kwnames[] = {
32879 NULL
32880 };
32881
32882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32883 {
32884 PyThreadState* __tstate = wxPyBeginAllowThreads();
32885 result = (wxValidator *)new wxValidator();
32886
32887 wxPyEndAllowThreads(__tstate);
32888 if (PyErr_Occurred()) SWIG_fail;
32889 }
32890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32891 return resultobj;
32892 fail:
32893 return NULL;
32894 }
32895
32896
32897 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32898 PyObject *resultobj;
32899 wxValidator *arg1 = (wxValidator *) 0 ;
32900 wxValidator *result;
32901 PyObject * obj0 = 0 ;
32902 char *kwnames[] = {
32903 (char *) "self", NULL
32904 };
32905
32906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32908 if (SWIG_arg_fail(1)) SWIG_fail;
32909 {
32910 PyThreadState* __tstate = wxPyBeginAllowThreads();
32911 result = (wxValidator *)(arg1)->Clone();
32912
32913 wxPyEndAllowThreads(__tstate);
32914 if (PyErr_Occurred()) SWIG_fail;
32915 }
32916 {
32917 resultobj = wxPyMake_wxObject(result, 0);
32918 }
32919 return resultobj;
32920 fail:
32921 return NULL;
32922 }
32923
32924
32925 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32926 PyObject *resultobj;
32927 wxValidator *arg1 = (wxValidator *) 0 ;
32928 wxWindow *arg2 = (wxWindow *) 0 ;
32929 bool result;
32930 PyObject * obj0 = 0 ;
32931 PyObject * obj1 = 0 ;
32932 char *kwnames[] = {
32933 (char *) "self",(char *) "parent", NULL
32934 };
32935
32936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32938 if (SWIG_arg_fail(1)) SWIG_fail;
32939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32940 if (SWIG_arg_fail(2)) SWIG_fail;
32941 {
32942 PyThreadState* __tstate = wxPyBeginAllowThreads();
32943 result = (bool)(arg1)->Validate(arg2);
32944
32945 wxPyEndAllowThreads(__tstate);
32946 if (PyErr_Occurred()) SWIG_fail;
32947 }
32948 {
32949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32950 }
32951 return resultobj;
32952 fail:
32953 return NULL;
32954 }
32955
32956
32957 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32958 PyObject *resultobj;
32959 wxValidator *arg1 = (wxValidator *) 0 ;
32960 bool result;
32961 PyObject * obj0 = 0 ;
32962 char *kwnames[] = {
32963 (char *) "self", NULL
32964 };
32965
32966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32968 if (SWIG_arg_fail(1)) SWIG_fail;
32969 {
32970 PyThreadState* __tstate = wxPyBeginAllowThreads();
32971 result = (bool)(arg1)->TransferToWindow();
32972
32973 wxPyEndAllowThreads(__tstate);
32974 if (PyErr_Occurred()) SWIG_fail;
32975 }
32976 {
32977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32978 }
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32986 PyObject *resultobj;
32987 wxValidator *arg1 = (wxValidator *) 0 ;
32988 bool result;
32989 PyObject * obj0 = 0 ;
32990 char *kwnames[] = {
32991 (char *) "self", NULL
32992 };
32993
32994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32996 if (SWIG_arg_fail(1)) SWIG_fail;
32997 {
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 result = (bool)(arg1)->TransferFromWindow();
33000
33001 wxPyEndAllowThreads(__tstate);
33002 if (PyErr_Occurred()) SWIG_fail;
33003 }
33004 {
33005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33006 }
33007 return resultobj;
33008 fail:
33009 return NULL;
33010 }
33011
33012
33013 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33014 PyObject *resultobj;
33015 wxValidator *arg1 = (wxValidator *) 0 ;
33016 wxWindow *result;
33017 PyObject * obj0 = 0 ;
33018 char *kwnames[] = {
33019 (char *) "self", NULL
33020 };
33021
33022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33024 if (SWIG_arg_fail(1)) SWIG_fail;
33025 {
33026 PyThreadState* __tstate = wxPyBeginAllowThreads();
33027 result = (wxWindow *)(arg1)->GetWindow();
33028
33029 wxPyEndAllowThreads(__tstate);
33030 if (PyErr_Occurred()) SWIG_fail;
33031 }
33032 {
33033 resultobj = wxPyMake_wxObject(result, 0);
33034 }
33035 return resultobj;
33036 fail:
33037 return NULL;
33038 }
33039
33040
33041 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33042 PyObject *resultobj;
33043 wxValidator *arg1 = (wxValidator *) 0 ;
33044 wxWindow *arg2 = (wxWindow *) 0 ;
33045 PyObject * obj0 = 0 ;
33046 PyObject * obj1 = 0 ;
33047 char *kwnames[] = {
33048 (char *) "self",(char *) "window", NULL
33049 };
33050
33051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33053 if (SWIG_arg_fail(1)) SWIG_fail;
33054 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(2)) SWIG_fail;
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 (arg1)->SetWindow(arg2);
33059
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 Py_INCREF(Py_None); resultobj = Py_None;
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33071 PyObject *resultobj;
33072 bool result;
33073 char *kwnames[] = {
33074 NULL
33075 };
33076
33077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = (bool)wxValidator::IsSilent();
33081
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 {
33086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33087 }
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33095 PyObject *resultobj;
33096 int arg1 = (int) true ;
33097 PyObject * obj0 = 0 ;
33098 char *kwnames[] = {
33099 (char *) "doIt", NULL
33100 };
33101
33102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33103 if (obj0) {
33104 {
33105 arg1 = (int)(SWIG_As_int(obj0));
33106 if (SWIG_arg_fail(1)) SWIG_fail;
33107 }
33108 }
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 wxValidator::SetBellOnError(arg1);
33112
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 Py_INCREF(Py_None); resultobj = Py_None;
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33124 PyObject *obj;
33125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33126 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33127 Py_INCREF(obj);
33128 return Py_BuildValue((char *)"");
33129 }
33130 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33131 PyObject *resultobj;
33132 wxPyValidator *result;
33133 char *kwnames[] = {
33134 NULL
33135 };
33136
33137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (wxPyValidator *)new wxPyValidator();
33141
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj;
33154 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33155 PyObject *arg2 = (PyObject *) 0 ;
33156 PyObject *arg3 = (PyObject *) 0 ;
33157 int arg4 = (int) true ;
33158 PyObject * obj0 = 0 ;
33159 PyObject * obj1 = 0 ;
33160 PyObject * obj2 = 0 ;
33161 PyObject * obj3 = 0 ;
33162 char *kwnames[] = {
33163 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33164 };
33165
33166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(1)) SWIG_fail;
33169 arg2 = obj1;
33170 arg3 = obj2;
33171 if (obj3) {
33172 {
33173 arg4 = (int)(SWIG_As_int(obj3));
33174 if (SWIG_arg_fail(4)) SWIG_fail;
33175 }
33176 }
33177 {
33178 PyThreadState* __tstate = wxPyBeginAllowThreads();
33179 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33180
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 Py_INCREF(Py_None); resultobj = Py_None;
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33192 PyObject *obj;
33193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33194 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33195 Py_INCREF(obj);
33196 return Py_BuildValue((char *)"");
33197 }
33198 static int _wrap_DefaultValidator_set(PyObject *) {
33199 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33200 return 1;
33201 }
33202
33203
33204 static PyObject *_wrap_DefaultValidator_get(void) {
33205 PyObject *pyobj;
33206
33207 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33208 return pyobj;
33209 }
33210
33211
33212 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj;
33214 wxString const &arg1_defvalue = wxPyEmptyString ;
33215 wxString *arg1 = (wxString *) &arg1_defvalue ;
33216 long arg2 = (long) 0 ;
33217 wxMenu *result;
33218 bool temp1 = false ;
33219 PyObject * obj0 = 0 ;
33220 PyObject * obj1 = 0 ;
33221 char *kwnames[] = {
33222 (char *) "title",(char *) "style", NULL
33223 };
33224
33225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33226 if (obj0) {
33227 {
33228 arg1 = wxString_in_helper(obj0);
33229 if (arg1 == NULL) SWIG_fail;
33230 temp1 = true;
33231 }
33232 }
33233 if (obj1) {
33234 {
33235 arg2 = (long)(SWIG_As_long(obj1));
33236 if (SWIG_arg_fail(2)) SWIG_fail;
33237 }
33238 }
33239 {
33240 if (!wxPyCheckForApp()) SWIG_fail;
33241 PyThreadState* __tstate = wxPyBeginAllowThreads();
33242 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33243
33244 wxPyEndAllowThreads(__tstate);
33245 if (PyErr_Occurred()) SWIG_fail;
33246 }
33247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33248 {
33249 if (temp1)
33250 delete arg1;
33251 }
33252 return resultobj;
33253 fail:
33254 {
33255 if (temp1)
33256 delete arg1;
33257 }
33258 return NULL;
33259 }
33260
33261
33262 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33263 PyObject *resultobj;
33264 wxMenu *arg1 = (wxMenu *) 0 ;
33265 int arg2 ;
33266 wxString *arg3 = 0 ;
33267 wxString const &arg4_defvalue = wxPyEmptyString ;
33268 wxString *arg4 = (wxString *) &arg4_defvalue ;
33269 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33270 wxMenuItem *result;
33271 bool temp3 = false ;
33272 bool temp4 = false ;
33273 PyObject * obj0 = 0 ;
33274 PyObject * obj1 = 0 ;
33275 PyObject * obj2 = 0 ;
33276 PyObject * obj3 = 0 ;
33277 PyObject * obj4 = 0 ;
33278 char *kwnames[] = {
33279 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33280 };
33281
33282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33284 if (SWIG_arg_fail(1)) SWIG_fail;
33285 {
33286 arg2 = (int)(SWIG_As_int(obj1));
33287 if (SWIG_arg_fail(2)) SWIG_fail;
33288 }
33289 {
33290 arg3 = wxString_in_helper(obj2);
33291 if (arg3 == NULL) SWIG_fail;
33292 temp3 = true;
33293 }
33294 if (obj3) {
33295 {
33296 arg4 = wxString_in_helper(obj3);
33297 if (arg4 == NULL) SWIG_fail;
33298 temp4 = true;
33299 }
33300 }
33301 if (obj4) {
33302 {
33303 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33304 if (SWIG_arg_fail(5)) SWIG_fail;
33305 }
33306 }
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33310
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 {
33315 resultobj = wxPyMake_wxObject(result, 0);
33316 }
33317 {
33318 if (temp3)
33319 delete arg3;
33320 }
33321 {
33322 if (temp4)
33323 delete arg4;
33324 }
33325 return resultobj;
33326 fail:
33327 {
33328 if (temp3)
33329 delete arg3;
33330 }
33331 {
33332 if (temp4)
33333 delete arg4;
33334 }
33335 return NULL;
33336 }
33337
33338
33339 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33340 PyObject *resultobj;
33341 wxMenu *arg1 = (wxMenu *) 0 ;
33342 wxMenuItem *result;
33343 PyObject * obj0 = 0 ;
33344 char *kwnames[] = {
33345 (char *) "self", NULL
33346 };
33347
33348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33350 if (SWIG_arg_fail(1)) SWIG_fail;
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = (wxMenuItem *)(arg1)->AppendSeparator();
33354
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 {
33359 resultobj = wxPyMake_wxObject(result, 0);
33360 }
33361 return resultobj;
33362 fail:
33363 return NULL;
33364 }
33365
33366
33367 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33368 PyObject *resultobj;
33369 wxMenu *arg1 = (wxMenu *) 0 ;
33370 int arg2 ;
33371 wxString *arg3 = 0 ;
33372 wxString const &arg4_defvalue = wxPyEmptyString ;
33373 wxString *arg4 = (wxString *) &arg4_defvalue ;
33374 wxMenuItem *result;
33375 bool temp3 = false ;
33376 bool temp4 = false ;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 PyObject * obj2 = 0 ;
33380 PyObject * obj3 = 0 ;
33381 char *kwnames[] = {
33382 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33383 };
33384
33385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33387 if (SWIG_arg_fail(1)) SWIG_fail;
33388 {
33389 arg2 = (int)(SWIG_As_int(obj1));
33390 if (SWIG_arg_fail(2)) SWIG_fail;
33391 }
33392 {
33393 arg3 = wxString_in_helper(obj2);
33394 if (arg3 == NULL) SWIG_fail;
33395 temp3 = true;
33396 }
33397 if (obj3) {
33398 {
33399 arg4 = wxString_in_helper(obj3);
33400 if (arg4 == NULL) SWIG_fail;
33401 temp4 = true;
33402 }
33403 }
33404 {
33405 PyThreadState* __tstate = wxPyBeginAllowThreads();
33406 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33407
33408 wxPyEndAllowThreads(__tstate);
33409 if (PyErr_Occurred()) SWIG_fail;
33410 }
33411 {
33412 resultobj = wxPyMake_wxObject(result, 0);
33413 }
33414 {
33415 if (temp3)
33416 delete arg3;
33417 }
33418 {
33419 if (temp4)
33420 delete arg4;
33421 }
33422 return resultobj;
33423 fail:
33424 {
33425 if (temp3)
33426 delete arg3;
33427 }
33428 {
33429 if (temp4)
33430 delete arg4;
33431 }
33432 return NULL;
33433 }
33434
33435
33436 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj;
33438 wxMenu *arg1 = (wxMenu *) 0 ;
33439 int arg2 ;
33440 wxString *arg3 = 0 ;
33441 wxString const &arg4_defvalue = wxPyEmptyString ;
33442 wxString *arg4 = (wxString *) &arg4_defvalue ;
33443 wxMenuItem *result;
33444 bool temp3 = false ;
33445 bool temp4 = false ;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 PyObject * obj2 = 0 ;
33449 PyObject * obj3 = 0 ;
33450 char *kwnames[] = {
33451 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33452 };
33453
33454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33456 if (SWIG_arg_fail(1)) SWIG_fail;
33457 {
33458 arg2 = (int)(SWIG_As_int(obj1));
33459 if (SWIG_arg_fail(2)) SWIG_fail;
33460 }
33461 {
33462 arg3 = wxString_in_helper(obj2);
33463 if (arg3 == NULL) SWIG_fail;
33464 temp3 = true;
33465 }
33466 if (obj3) {
33467 {
33468 arg4 = wxString_in_helper(obj3);
33469 if (arg4 == NULL) SWIG_fail;
33470 temp4 = true;
33471 }
33472 }
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33476
33477 wxPyEndAllowThreads(__tstate);
33478 if (PyErr_Occurred()) SWIG_fail;
33479 }
33480 {
33481 resultobj = wxPyMake_wxObject(result, 0);
33482 }
33483 {
33484 if (temp3)
33485 delete arg3;
33486 }
33487 {
33488 if (temp4)
33489 delete arg4;
33490 }
33491 return resultobj;
33492 fail:
33493 {
33494 if (temp3)
33495 delete arg3;
33496 }
33497 {
33498 if (temp4)
33499 delete arg4;
33500 }
33501 return NULL;
33502 }
33503
33504
33505 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33506 PyObject *resultobj;
33507 wxMenu *arg1 = (wxMenu *) 0 ;
33508 int arg2 ;
33509 wxString *arg3 = 0 ;
33510 wxMenu *arg4 = (wxMenu *) 0 ;
33511 wxString const &arg5_defvalue = wxPyEmptyString ;
33512 wxString *arg5 = (wxString *) &arg5_defvalue ;
33513 wxMenuItem *result;
33514 bool temp3 = false ;
33515 bool temp5 = false ;
33516 PyObject * obj0 = 0 ;
33517 PyObject * obj1 = 0 ;
33518 PyObject * obj2 = 0 ;
33519 PyObject * obj3 = 0 ;
33520 PyObject * obj4 = 0 ;
33521 char *kwnames[] = {
33522 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33523 };
33524
33525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33527 if (SWIG_arg_fail(1)) SWIG_fail;
33528 {
33529 arg2 = (int)(SWIG_As_int(obj1));
33530 if (SWIG_arg_fail(2)) SWIG_fail;
33531 }
33532 {
33533 arg3 = wxString_in_helper(obj2);
33534 if (arg3 == NULL) SWIG_fail;
33535 temp3 = true;
33536 }
33537 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33538 if (SWIG_arg_fail(4)) SWIG_fail;
33539 if (obj4) {
33540 {
33541 arg5 = wxString_in_helper(obj4);
33542 if (arg5 == NULL) SWIG_fail;
33543 temp5 = true;
33544 }
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33549
33550 wxPyEndAllowThreads(__tstate);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 }
33553 {
33554 resultobj = wxPyMake_wxObject(result, 0);
33555 }
33556 {
33557 if (temp3)
33558 delete arg3;
33559 }
33560 {
33561 if (temp5)
33562 delete arg5;
33563 }
33564 return resultobj;
33565 fail:
33566 {
33567 if (temp3)
33568 delete arg3;
33569 }
33570 {
33571 if (temp5)
33572 delete arg5;
33573 }
33574 return NULL;
33575 }
33576
33577
33578 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33579 PyObject *resultobj;
33580 wxMenu *arg1 = (wxMenu *) 0 ;
33581 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33582 wxMenuItem *result;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 char *kwnames[] = {
33586 (char *) "self",(char *) "item", NULL
33587 };
33588
33589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33591 if (SWIG_arg_fail(1)) SWIG_fail;
33592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33593 if (SWIG_arg_fail(2)) SWIG_fail;
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (wxMenuItem *)(arg1)->Append(arg2);
33597
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 {
33602 resultobj = wxPyMake_wxObject(result, 0);
33603 }
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33611 PyObject *resultobj;
33612 wxMenu *arg1 = (wxMenu *) 0 ;
33613 PyObject * obj0 = 0 ;
33614 char *kwnames[] = {
33615 (char *) "self", NULL
33616 };
33617
33618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33620 if (SWIG_arg_fail(1)) SWIG_fail;
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 (arg1)->Break();
33624
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 Py_INCREF(Py_None); resultobj = Py_None;
33629 return resultobj;
33630 fail:
33631 return NULL;
33632 }
33633
33634
33635 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33636 PyObject *resultobj;
33637 wxMenu *arg1 = (wxMenu *) 0 ;
33638 size_t arg2 ;
33639 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33640 wxMenuItem *result;
33641 PyObject * obj0 = 0 ;
33642 PyObject * obj1 = 0 ;
33643 PyObject * obj2 = 0 ;
33644 char *kwnames[] = {
33645 (char *) "self",(char *) "pos",(char *) "item", NULL
33646 };
33647
33648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33650 if (SWIG_arg_fail(1)) SWIG_fail;
33651 {
33652 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33653 if (SWIG_arg_fail(2)) SWIG_fail;
33654 }
33655 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33656 if (SWIG_arg_fail(3)) SWIG_fail;
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33660
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 {
33665 resultobj = wxPyMake_wxObject(result, 0);
33666 }
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj;
33675 wxMenu *arg1 = (wxMenu *) 0 ;
33676 size_t arg2 ;
33677 int arg3 ;
33678 wxString *arg4 = 0 ;
33679 wxString const &arg5_defvalue = wxPyEmptyString ;
33680 wxString *arg5 = (wxString *) &arg5_defvalue ;
33681 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33682 wxMenuItem *result;
33683 bool temp4 = false ;
33684 bool temp5 = false ;
33685 PyObject * obj0 = 0 ;
33686 PyObject * obj1 = 0 ;
33687 PyObject * obj2 = 0 ;
33688 PyObject * obj3 = 0 ;
33689 PyObject * obj4 = 0 ;
33690 PyObject * obj5 = 0 ;
33691 char *kwnames[] = {
33692 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33693 };
33694
33695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33697 if (SWIG_arg_fail(1)) SWIG_fail;
33698 {
33699 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33700 if (SWIG_arg_fail(2)) SWIG_fail;
33701 }
33702 {
33703 arg3 = (int)(SWIG_As_int(obj2));
33704 if (SWIG_arg_fail(3)) SWIG_fail;
33705 }
33706 {
33707 arg4 = wxString_in_helper(obj3);
33708 if (arg4 == NULL) SWIG_fail;
33709 temp4 = true;
33710 }
33711 if (obj4) {
33712 {
33713 arg5 = wxString_in_helper(obj4);
33714 if (arg5 == NULL) SWIG_fail;
33715 temp5 = true;
33716 }
33717 }
33718 if (obj5) {
33719 {
33720 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33721 if (SWIG_arg_fail(6)) SWIG_fail;
33722 }
33723 }
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33727
33728 wxPyEndAllowThreads(__tstate);
33729 if (PyErr_Occurred()) SWIG_fail;
33730 }
33731 {
33732 resultobj = wxPyMake_wxObject(result, 0);
33733 }
33734 {
33735 if (temp4)
33736 delete arg4;
33737 }
33738 {
33739 if (temp5)
33740 delete arg5;
33741 }
33742 return resultobj;
33743 fail:
33744 {
33745 if (temp4)
33746 delete arg4;
33747 }
33748 {
33749 if (temp5)
33750 delete arg5;
33751 }
33752 return NULL;
33753 }
33754
33755
33756 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33757 PyObject *resultobj;
33758 wxMenu *arg1 = (wxMenu *) 0 ;
33759 size_t arg2 ;
33760 wxMenuItem *result;
33761 PyObject * obj0 = 0 ;
33762 PyObject * obj1 = 0 ;
33763 char *kwnames[] = {
33764 (char *) "self",(char *) "pos", NULL
33765 };
33766
33767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33769 if (SWIG_arg_fail(1)) SWIG_fail;
33770 {
33771 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33772 if (SWIG_arg_fail(2)) SWIG_fail;
33773 }
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33777
33778 wxPyEndAllowThreads(__tstate);
33779 if (PyErr_Occurred()) SWIG_fail;
33780 }
33781 {
33782 resultobj = wxPyMake_wxObject(result, 0);
33783 }
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33791 PyObject *resultobj;
33792 wxMenu *arg1 = (wxMenu *) 0 ;
33793 size_t arg2 ;
33794 int arg3 ;
33795 wxString *arg4 = 0 ;
33796 wxString const &arg5_defvalue = wxPyEmptyString ;
33797 wxString *arg5 = (wxString *) &arg5_defvalue ;
33798 wxMenuItem *result;
33799 bool temp4 = false ;
33800 bool temp5 = false ;
33801 PyObject * obj0 = 0 ;
33802 PyObject * obj1 = 0 ;
33803 PyObject * obj2 = 0 ;
33804 PyObject * obj3 = 0 ;
33805 PyObject * obj4 = 0 ;
33806 char *kwnames[] = {
33807 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33808 };
33809
33810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33812 if (SWIG_arg_fail(1)) SWIG_fail;
33813 {
33814 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33815 if (SWIG_arg_fail(2)) SWIG_fail;
33816 }
33817 {
33818 arg3 = (int)(SWIG_As_int(obj2));
33819 if (SWIG_arg_fail(3)) SWIG_fail;
33820 }
33821 {
33822 arg4 = wxString_in_helper(obj3);
33823 if (arg4 == NULL) SWIG_fail;
33824 temp4 = true;
33825 }
33826 if (obj4) {
33827 {
33828 arg5 = wxString_in_helper(obj4);
33829 if (arg5 == NULL) SWIG_fail;
33830 temp5 = true;
33831 }
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33836
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 {
33841 resultobj = wxPyMake_wxObject(result, 0);
33842 }
33843 {
33844 if (temp4)
33845 delete arg4;
33846 }
33847 {
33848 if (temp5)
33849 delete arg5;
33850 }
33851 return resultobj;
33852 fail:
33853 {
33854 if (temp4)
33855 delete arg4;
33856 }
33857 {
33858 if (temp5)
33859 delete arg5;
33860 }
33861 return NULL;
33862 }
33863
33864
33865 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33866 PyObject *resultobj;
33867 wxMenu *arg1 = (wxMenu *) 0 ;
33868 size_t arg2 ;
33869 int arg3 ;
33870 wxString *arg4 = 0 ;
33871 wxString const &arg5_defvalue = wxPyEmptyString ;
33872 wxString *arg5 = (wxString *) &arg5_defvalue ;
33873 wxMenuItem *result;
33874 bool temp4 = false ;
33875 bool temp5 = false ;
33876 PyObject * obj0 = 0 ;
33877 PyObject * obj1 = 0 ;
33878 PyObject * obj2 = 0 ;
33879 PyObject * obj3 = 0 ;
33880 PyObject * obj4 = 0 ;
33881 char *kwnames[] = {
33882 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33883 };
33884
33885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33887 if (SWIG_arg_fail(1)) SWIG_fail;
33888 {
33889 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33890 if (SWIG_arg_fail(2)) SWIG_fail;
33891 }
33892 {
33893 arg3 = (int)(SWIG_As_int(obj2));
33894 if (SWIG_arg_fail(3)) SWIG_fail;
33895 }
33896 {
33897 arg4 = wxString_in_helper(obj3);
33898 if (arg4 == NULL) SWIG_fail;
33899 temp4 = true;
33900 }
33901 if (obj4) {
33902 {
33903 arg5 = wxString_in_helper(obj4);
33904 if (arg5 == NULL) SWIG_fail;
33905 temp5 = true;
33906 }
33907 }
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33911
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 {
33916 resultobj = wxPyMake_wxObject(result, 0);
33917 }
33918 {
33919 if (temp4)
33920 delete arg4;
33921 }
33922 {
33923 if (temp5)
33924 delete arg5;
33925 }
33926 return resultobj;
33927 fail:
33928 {
33929 if (temp4)
33930 delete arg4;
33931 }
33932 {
33933 if (temp5)
33934 delete arg5;
33935 }
33936 return NULL;
33937 }
33938
33939
33940 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33941 PyObject *resultobj;
33942 wxMenu *arg1 = (wxMenu *) 0 ;
33943 size_t arg2 ;
33944 int arg3 ;
33945 wxString *arg4 = 0 ;
33946 wxMenu *arg5 = (wxMenu *) 0 ;
33947 wxString const &arg6_defvalue = wxPyEmptyString ;
33948 wxString *arg6 = (wxString *) &arg6_defvalue ;
33949 wxMenuItem *result;
33950 bool temp4 = false ;
33951 bool temp6 = false ;
33952 PyObject * obj0 = 0 ;
33953 PyObject * obj1 = 0 ;
33954 PyObject * obj2 = 0 ;
33955 PyObject * obj3 = 0 ;
33956 PyObject * obj4 = 0 ;
33957 PyObject * obj5 = 0 ;
33958 char *kwnames[] = {
33959 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33960 };
33961
33962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33964 if (SWIG_arg_fail(1)) SWIG_fail;
33965 {
33966 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33967 if (SWIG_arg_fail(2)) SWIG_fail;
33968 }
33969 {
33970 arg3 = (int)(SWIG_As_int(obj2));
33971 if (SWIG_arg_fail(3)) SWIG_fail;
33972 }
33973 {
33974 arg4 = wxString_in_helper(obj3);
33975 if (arg4 == NULL) SWIG_fail;
33976 temp4 = true;
33977 }
33978 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33979 if (SWIG_arg_fail(5)) SWIG_fail;
33980 if (obj5) {
33981 {
33982 arg6 = wxString_in_helper(obj5);
33983 if (arg6 == NULL) SWIG_fail;
33984 temp6 = true;
33985 }
33986 }
33987 {
33988 PyThreadState* __tstate = wxPyBeginAllowThreads();
33989 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33990
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 {
33995 resultobj = wxPyMake_wxObject(result, 0);
33996 }
33997 {
33998 if (temp4)
33999 delete arg4;
34000 }
34001 {
34002 if (temp6)
34003 delete arg6;
34004 }
34005 return resultobj;
34006 fail:
34007 {
34008 if (temp4)
34009 delete arg4;
34010 }
34011 {
34012 if (temp6)
34013 delete arg6;
34014 }
34015 return NULL;
34016 }
34017
34018
34019 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34020 PyObject *resultobj;
34021 wxMenu *arg1 = (wxMenu *) 0 ;
34022 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34023 wxMenuItem *result;
34024 PyObject * obj0 = 0 ;
34025 PyObject * obj1 = 0 ;
34026 char *kwnames[] = {
34027 (char *) "self",(char *) "item", NULL
34028 };
34029
34030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34032 if (SWIG_arg_fail(1)) SWIG_fail;
34033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34034 if (SWIG_arg_fail(2)) SWIG_fail;
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34038
34039 wxPyEndAllowThreads(__tstate);
34040 if (PyErr_Occurred()) SWIG_fail;
34041 }
34042 {
34043 resultobj = wxPyMake_wxObject(result, 0);
34044 }
34045 return resultobj;
34046 fail:
34047 return NULL;
34048 }
34049
34050
34051 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34052 PyObject *resultobj;
34053 wxMenu *arg1 = (wxMenu *) 0 ;
34054 int arg2 ;
34055 wxString *arg3 = 0 ;
34056 wxString const &arg4_defvalue = wxPyEmptyString ;
34057 wxString *arg4 = (wxString *) &arg4_defvalue ;
34058 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34059 wxMenuItem *result;
34060 bool temp3 = false ;
34061 bool temp4 = false ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 PyObject * obj2 = 0 ;
34065 PyObject * obj3 = 0 ;
34066 PyObject * obj4 = 0 ;
34067 char *kwnames[] = {
34068 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34069 };
34070
34071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34073 if (SWIG_arg_fail(1)) SWIG_fail;
34074 {
34075 arg2 = (int)(SWIG_As_int(obj1));
34076 if (SWIG_arg_fail(2)) SWIG_fail;
34077 }
34078 {
34079 arg3 = wxString_in_helper(obj2);
34080 if (arg3 == NULL) SWIG_fail;
34081 temp3 = true;
34082 }
34083 if (obj3) {
34084 {
34085 arg4 = wxString_in_helper(obj3);
34086 if (arg4 == NULL) SWIG_fail;
34087 temp4 = true;
34088 }
34089 }
34090 if (obj4) {
34091 {
34092 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34093 if (SWIG_arg_fail(5)) SWIG_fail;
34094 }
34095 }
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
34099
34100 wxPyEndAllowThreads(__tstate);
34101 if (PyErr_Occurred()) SWIG_fail;
34102 }
34103 {
34104 resultobj = wxPyMake_wxObject(result, 0);
34105 }
34106 {
34107 if (temp3)
34108 delete arg3;
34109 }
34110 {
34111 if (temp4)
34112 delete arg4;
34113 }
34114 return resultobj;
34115 fail:
34116 {
34117 if (temp3)
34118 delete arg3;
34119 }
34120 {
34121 if (temp4)
34122 delete arg4;
34123 }
34124 return NULL;
34125 }
34126
34127
34128 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj;
34130 wxMenu *arg1 = (wxMenu *) 0 ;
34131 wxMenuItem *result;
34132 PyObject * obj0 = 0 ;
34133 char *kwnames[] = {
34134 (char *) "self", NULL
34135 };
34136
34137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34139 if (SWIG_arg_fail(1)) SWIG_fail;
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 result = (wxMenuItem *)(arg1)->PrependSeparator();
34143
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 {
34148 resultobj = wxPyMake_wxObject(result, 0);
34149 }
34150 return resultobj;
34151 fail:
34152 return NULL;
34153 }
34154
34155
34156 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34157 PyObject *resultobj;
34158 wxMenu *arg1 = (wxMenu *) 0 ;
34159 int arg2 ;
34160 wxString *arg3 = 0 ;
34161 wxString const &arg4_defvalue = wxPyEmptyString ;
34162 wxString *arg4 = (wxString *) &arg4_defvalue ;
34163 wxMenuItem *result;
34164 bool temp3 = false ;
34165 bool temp4 = false ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 PyObject * obj2 = 0 ;
34169 PyObject * obj3 = 0 ;
34170 char *kwnames[] = {
34171 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34172 };
34173
34174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34176 if (SWIG_arg_fail(1)) SWIG_fail;
34177 {
34178 arg2 = (int)(SWIG_As_int(obj1));
34179 if (SWIG_arg_fail(2)) SWIG_fail;
34180 }
34181 {
34182 arg3 = wxString_in_helper(obj2);
34183 if (arg3 == NULL) SWIG_fail;
34184 temp3 = true;
34185 }
34186 if (obj3) {
34187 {
34188 arg4 = wxString_in_helper(obj3);
34189 if (arg4 == NULL) SWIG_fail;
34190 temp4 = true;
34191 }
34192 }
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34196
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 {
34201 resultobj = wxPyMake_wxObject(result, 0);
34202 }
34203 {
34204 if (temp3)
34205 delete arg3;
34206 }
34207 {
34208 if (temp4)
34209 delete arg4;
34210 }
34211 return resultobj;
34212 fail:
34213 {
34214 if (temp3)
34215 delete arg3;
34216 }
34217 {
34218 if (temp4)
34219 delete arg4;
34220 }
34221 return NULL;
34222 }
34223
34224
34225 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34226 PyObject *resultobj;
34227 wxMenu *arg1 = (wxMenu *) 0 ;
34228 int arg2 ;
34229 wxString *arg3 = 0 ;
34230 wxString const &arg4_defvalue = wxPyEmptyString ;
34231 wxString *arg4 = (wxString *) &arg4_defvalue ;
34232 wxMenuItem *result;
34233 bool temp3 = false ;
34234 bool temp4 = false ;
34235 PyObject * obj0 = 0 ;
34236 PyObject * obj1 = 0 ;
34237 PyObject * obj2 = 0 ;
34238 PyObject * obj3 = 0 ;
34239 char *kwnames[] = {
34240 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34241 };
34242
34243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34245 if (SWIG_arg_fail(1)) SWIG_fail;
34246 {
34247 arg2 = (int)(SWIG_As_int(obj1));
34248 if (SWIG_arg_fail(2)) SWIG_fail;
34249 }
34250 {
34251 arg3 = wxString_in_helper(obj2);
34252 if (arg3 == NULL) SWIG_fail;
34253 temp3 = true;
34254 }
34255 if (obj3) {
34256 {
34257 arg4 = wxString_in_helper(obj3);
34258 if (arg4 == NULL) SWIG_fail;
34259 temp4 = true;
34260 }
34261 }
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34265
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 {
34270 resultobj = wxPyMake_wxObject(result, 0);
34271 }
34272 {
34273 if (temp3)
34274 delete arg3;
34275 }
34276 {
34277 if (temp4)
34278 delete arg4;
34279 }
34280 return resultobj;
34281 fail:
34282 {
34283 if (temp3)
34284 delete arg3;
34285 }
34286 {
34287 if (temp4)
34288 delete arg4;
34289 }
34290 return NULL;
34291 }
34292
34293
34294 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 wxMenu *arg1 = (wxMenu *) 0 ;
34297 int arg2 ;
34298 wxString *arg3 = 0 ;
34299 wxMenu *arg4 = (wxMenu *) 0 ;
34300 wxString const &arg5_defvalue = wxPyEmptyString ;
34301 wxString *arg5 = (wxString *) &arg5_defvalue ;
34302 wxMenuItem *result;
34303 bool temp3 = false ;
34304 bool temp5 = false ;
34305 PyObject * obj0 = 0 ;
34306 PyObject * obj1 = 0 ;
34307 PyObject * obj2 = 0 ;
34308 PyObject * obj3 = 0 ;
34309 PyObject * obj4 = 0 ;
34310 char *kwnames[] = {
34311 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34312 };
34313
34314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34316 if (SWIG_arg_fail(1)) SWIG_fail;
34317 {
34318 arg2 = (int)(SWIG_As_int(obj1));
34319 if (SWIG_arg_fail(2)) SWIG_fail;
34320 }
34321 {
34322 arg3 = wxString_in_helper(obj2);
34323 if (arg3 == NULL) SWIG_fail;
34324 temp3 = true;
34325 }
34326 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34327 if (SWIG_arg_fail(4)) SWIG_fail;
34328 if (obj4) {
34329 {
34330 arg5 = wxString_in_helper(obj4);
34331 if (arg5 == NULL) SWIG_fail;
34332 temp5 = true;
34333 }
34334 }
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34338
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 resultobj = wxPyMake_wxObject(result, 0);
34344 }
34345 {
34346 if (temp3)
34347 delete arg3;
34348 }
34349 {
34350 if (temp5)
34351 delete arg5;
34352 }
34353 return resultobj;
34354 fail:
34355 {
34356 if (temp3)
34357 delete arg3;
34358 }
34359 {
34360 if (temp5)
34361 delete arg5;
34362 }
34363 return NULL;
34364 }
34365
34366
34367 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34368 PyObject *resultobj;
34369 wxMenu *arg1 = (wxMenu *) 0 ;
34370 int arg2 ;
34371 wxMenuItem *result;
34372 PyObject * obj0 = 0 ;
34373 PyObject * obj1 = 0 ;
34374 char *kwnames[] = {
34375 (char *) "self",(char *) "id", NULL
34376 };
34377
34378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(1)) SWIG_fail;
34381 {
34382 arg2 = (int)(SWIG_As_int(obj1));
34383 if (SWIG_arg_fail(2)) SWIG_fail;
34384 }
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 result = (wxMenuItem *)(arg1)->Remove(arg2);
34388
34389 wxPyEndAllowThreads(__tstate);
34390 if (PyErr_Occurred()) SWIG_fail;
34391 }
34392 {
34393 resultobj = wxPyMake_wxObject(result, 0);
34394 }
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34402 PyObject *resultobj;
34403 wxMenu *arg1 = (wxMenu *) 0 ;
34404 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34405 wxMenuItem *result;
34406 PyObject * obj0 = 0 ;
34407 PyObject * obj1 = 0 ;
34408 char *kwnames[] = {
34409 (char *) "self",(char *) "item", NULL
34410 };
34411
34412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34414 if (SWIG_arg_fail(1)) SWIG_fail;
34415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34416 if (SWIG_arg_fail(2)) SWIG_fail;
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 result = (wxMenuItem *)(arg1)->Remove(arg2);
34420
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 {
34425 resultobj = wxPyMake_wxObject(result, 0);
34426 }
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34434 PyObject *resultobj;
34435 wxMenu *arg1 = (wxMenu *) 0 ;
34436 int arg2 ;
34437 bool result;
34438 PyObject * obj0 = 0 ;
34439 PyObject * obj1 = 0 ;
34440 char *kwnames[] = {
34441 (char *) "self",(char *) "id", NULL
34442 };
34443
34444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34446 if (SWIG_arg_fail(1)) SWIG_fail;
34447 {
34448 arg2 = (int)(SWIG_As_int(obj1));
34449 if (SWIG_arg_fail(2)) SWIG_fail;
34450 }
34451 {
34452 PyThreadState* __tstate = wxPyBeginAllowThreads();
34453 result = (bool)(arg1)->Delete(arg2);
34454
34455 wxPyEndAllowThreads(__tstate);
34456 if (PyErr_Occurred()) SWIG_fail;
34457 }
34458 {
34459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34460 }
34461 return resultobj;
34462 fail:
34463 return NULL;
34464 }
34465
34466
34467 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34468 PyObject *resultobj;
34469 wxMenu *arg1 = (wxMenu *) 0 ;
34470 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34471 bool result;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 char *kwnames[] = {
34475 (char *) "self",(char *) "item", NULL
34476 };
34477
34478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34480 if (SWIG_arg_fail(1)) SWIG_fail;
34481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34482 if (SWIG_arg_fail(2)) SWIG_fail;
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 result = (bool)(arg1)->Delete(arg2);
34486
34487 wxPyEndAllowThreads(__tstate);
34488 if (PyErr_Occurred()) SWIG_fail;
34489 }
34490 {
34491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34492 }
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34500 PyObject *resultobj;
34501 wxMenu *arg1 = (wxMenu *) 0 ;
34502 PyObject * obj0 = 0 ;
34503 char *kwnames[] = {
34504 (char *) "self", NULL
34505 };
34506
34507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34509 if (SWIG_arg_fail(1)) SWIG_fail;
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 wxMenu_Destroy(arg1);
34513
34514 wxPyEndAllowThreads(__tstate);
34515 if (PyErr_Occurred()) SWIG_fail;
34516 }
34517 Py_INCREF(Py_None); resultobj = Py_None;
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34525 PyObject *resultobj;
34526 wxMenu *arg1 = (wxMenu *) 0 ;
34527 int arg2 ;
34528 bool result;
34529 PyObject * obj0 = 0 ;
34530 PyObject * obj1 = 0 ;
34531 char *kwnames[] = {
34532 (char *) "self",(char *) "id", NULL
34533 };
34534
34535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34537 if (SWIG_arg_fail(1)) SWIG_fail;
34538 {
34539 arg2 = (int)(SWIG_As_int(obj1));
34540 if (SWIG_arg_fail(2)) SWIG_fail;
34541 }
34542 {
34543 PyThreadState* __tstate = wxPyBeginAllowThreads();
34544 result = (bool)(arg1)->Destroy(arg2);
34545
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 {
34550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34551 }
34552 return resultobj;
34553 fail:
34554 return NULL;
34555 }
34556
34557
34558 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj;
34560 wxMenu *arg1 = (wxMenu *) 0 ;
34561 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34562 bool result;
34563 PyObject * obj0 = 0 ;
34564 PyObject * obj1 = 0 ;
34565 char *kwnames[] = {
34566 (char *) "self",(char *) "item", NULL
34567 };
34568
34569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34571 if (SWIG_arg_fail(1)) SWIG_fail;
34572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34573 if (SWIG_arg_fail(2)) SWIG_fail;
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (bool)(arg1)->Destroy(arg2);
34577
34578 wxPyEndAllowThreads(__tstate);
34579 if (PyErr_Occurred()) SWIG_fail;
34580 }
34581 {
34582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34583 }
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 size_t result;
34594 PyObject * obj0 = 0 ;
34595 char *kwnames[] = {
34596 (char *) "self", NULL
34597 };
34598
34599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34601 if (SWIG_arg_fail(1)) SWIG_fail;
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34605
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 {
34610 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34611 }
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34619 PyObject *resultobj;
34620 wxMenu *arg1 = (wxMenu *) 0 ;
34621 PyObject *result;
34622 PyObject * obj0 = 0 ;
34623 char *kwnames[] = {
34624 (char *) "self", NULL
34625 };
34626
34627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34629 if (SWIG_arg_fail(1)) SWIG_fail;
34630 {
34631 PyThreadState* __tstate = wxPyBeginAllowThreads();
34632 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34633
34634 wxPyEndAllowThreads(__tstate);
34635 if (PyErr_Occurred()) SWIG_fail;
34636 }
34637 resultobj = result;
34638 return resultobj;
34639 fail:
34640 return NULL;
34641 }
34642
34643
34644 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34645 PyObject *resultobj;
34646 wxMenu *arg1 = (wxMenu *) 0 ;
34647 wxString *arg2 = 0 ;
34648 int result;
34649 bool temp2 = false ;
34650 PyObject * obj0 = 0 ;
34651 PyObject * obj1 = 0 ;
34652 char *kwnames[] = {
34653 (char *) "self",(char *) "item", NULL
34654 };
34655
34656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34658 if (SWIG_arg_fail(1)) SWIG_fail;
34659 {
34660 arg2 = wxString_in_helper(obj1);
34661 if (arg2 == NULL) SWIG_fail;
34662 temp2 = true;
34663 }
34664 {
34665 PyThreadState* __tstate = wxPyBeginAllowThreads();
34666 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34667
34668 wxPyEndAllowThreads(__tstate);
34669 if (PyErr_Occurred()) SWIG_fail;
34670 }
34671 {
34672 resultobj = SWIG_From_int((int)(result));
34673 }
34674 {
34675 if (temp2)
34676 delete arg2;
34677 }
34678 return resultobj;
34679 fail:
34680 {
34681 if (temp2)
34682 delete arg2;
34683 }
34684 return NULL;
34685 }
34686
34687
34688 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34689 PyObject *resultobj;
34690 wxMenu *arg1 = (wxMenu *) 0 ;
34691 int arg2 ;
34692 wxMenuItem *result;
34693 PyObject * obj0 = 0 ;
34694 PyObject * obj1 = 0 ;
34695 char *kwnames[] = {
34696 (char *) "self",(char *) "id", NULL
34697 };
34698
34699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34701 if (SWIG_arg_fail(1)) SWIG_fail;
34702 {
34703 arg2 = (int)(SWIG_As_int(obj1));
34704 if (SWIG_arg_fail(2)) SWIG_fail;
34705 }
34706 {
34707 PyThreadState* __tstate = wxPyBeginAllowThreads();
34708 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34709
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 {
34714 resultobj = wxPyMake_wxObject(result, 0);
34715 }
34716 return resultobj;
34717 fail:
34718 return NULL;
34719 }
34720
34721
34722 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34723 PyObject *resultobj;
34724 wxMenu *arg1 = (wxMenu *) 0 ;
34725 size_t arg2 ;
34726 wxMenuItem *result;
34727 PyObject * obj0 = 0 ;
34728 PyObject * obj1 = 0 ;
34729 char *kwnames[] = {
34730 (char *) "self",(char *) "position", NULL
34731 };
34732
34733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34735 if (SWIG_arg_fail(1)) SWIG_fail;
34736 {
34737 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34738 if (SWIG_arg_fail(2)) SWIG_fail;
34739 }
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34743
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 {
34748 resultobj = wxPyMake_wxObject(result, 0);
34749 }
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34757 PyObject *resultobj;
34758 wxMenu *arg1 = (wxMenu *) 0 ;
34759 int arg2 ;
34760 bool arg3 ;
34761 PyObject * obj0 = 0 ;
34762 PyObject * obj1 = 0 ;
34763 PyObject * obj2 = 0 ;
34764 char *kwnames[] = {
34765 (char *) "self",(char *) "id",(char *) "enable", NULL
34766 };
34767
34768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34770 if (SWIG_arg_fail(1)) SWIG_fail;
34771 {
34772 arg2 = (int)(SWIG_As_int(obj1));
34773 if (SWIG_arg_fail(2)) SWIG_fail;
34774 }
34775 {
34776 arg3 = (bool)(SWIG_As_bool(obj2));
34777 if (SWIG_arg_fail(3)) SWIG_fail;
34778 }
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 (arg1)->Enable(arg2,arg3);
34782
34783 wxPyEndAllowThreads(__tstate);
34784 if (PyErr_Occurred()) SWIG_fail;
34785 }
34786 Py_INCREF(Py_None); resultobj = Py_None;
34787 return resultobj;
34788 fail:
34789 return NULL;
34790 }
34791
34792
34793 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34794 PyObject *resultobj;
34795 wxMenu *arg1 = (wxMenu *) 0 ;
34796 int arg2 ;
34797 bool result;
34798 PyObject * obj0 = 0 ;
34799 PyObject * obj1 = 0 ;
34800 char *kwnames[] = {
34801 (char *) "self",(char *) "id", NULL
34802 };
34803
34804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34806 if (SWIG_arg_fail(1)) SWIG_fail;
34807 {
34808 arg2 = (int)(SWIG_As_int(obj1));
34809 if (SWIG_arg_fail(2)) SWIG_fail;
34810 }
34811 {
34812 PyThreadState* __tstate = wxPyBeginAllowThreads();
34813 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34814
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 {
34819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34820 }
34821 return resultobj;
34822 fail:
34823 return NULL;
34824 }
34825
34826
34827 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34828 PyObject *resultobj;
34829 wxMenu *arg1 = (wxMenu *) 0 ;
34830 int arg2 ;
34831 bool arg3 ;
34832 PyObject * obj0 = 0 ;
34833 PyObject * obj1 = 0 ;
34834 PyObject * obj2 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self",(char *) "id",(char *) "check", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 {
34843 arg2 = (int)(SWIG_As_int(obj1));
34844 if (SWIG_arg_fail(2)) SWIG_fail;
34845 }
34846 {
34847 arg3 = (bool)(SWIG_As_bool(obj2));
34848 if (SWIG_arg_fail(3)) SWIG_fail;
34849 }
34850 {
34851 PyThreadState* __tstate = wxPyBeginAllowThreads();
34852 (arg1)->Check(arg2,arg3);
34853
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 Py_INCREF(Py_None); resultobj = Py_None;
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34865 PyObject *resultobj;
34866 wxMenu *arg1 = (wxMenu *) 0 ;
34867 int arg2 ;
34868 bool result;
34869 PyObject * obj0 = 0 ;
34870 PyObject * obj1 = 0 ;
34871 char *kwnames[] = {
34872 (char *) "self",(char *) "id", NULL
34873 };
34874
34875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34877 if (SWIG_arg_fail(1)) SWIG_fail;
34878 {
34879 arg2 = (int)(SWIG_As_int(obj1));
34880 if (SWIG_arg_fail(2)) SWIG_fail;
34881 }
34882 {
34883 PyThreadState* __tstate = wxPyBeginAllowThreads();
34884 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34885
34886 wxPyEndAllowThreads(__tstate);
34887 if (PyErr_Occurred()) SWIG_fail;
34888 }
34889 {
34890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34891 }
34892 return resultobj;
34893 fail:
34894 return NULL;
34895 }
34896
34897
34898 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34899 PyObject *resultobj;
34900 wxMenu *arg1 = (wxMenu *) 0 ;
34901 int arg2 ;
34902 wxString *arg3 = 0 ;
34903 bool temp3 = false ;
34904 PyObject * obj0 = 0 ;
34905 PyObject * obj1 = 0 ;
34906 PyObject * obj2 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "self",(char *) "id",(char *) "label", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34913 if (SWIG_arg_fail(1)) SWIG_fail;
34914 {
34915 arg2 = (int)(SWIG_As_int(obj1));
34916 if (SWIG_arg_fail(2)) SWIG_fail;
34917 }
34918 {
34919 arg3 = wxString_in_helper(obj2);
34920 if (arg3 == NULL) SWIG_fail;
34921 temp3 = true;
34922 }
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34926
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 Py_INCREF(Py_None); resultobj = Py_None;
34931 {
34932 if (temp3)
34933 delete arg3;
34934 }
34935 return resultobj;
34936 fail:
34937 {
34938 if (temp3)
34939 delete arg3;
34940 }
34941 return NULL;
34942 }
34943
34944
34945 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj;
34947 wxMenu *arg1 = (wxMenu *) 0 ;
34948 int arg2 ;
34949 wxString result;
34950 PyObject * obj0 = 0 ;
34951 PyObject * obj1 = 0 ;
34952 char *kwnames[] = {
34953 (char *) "self",(char *) "id", NULL
34954 };
34955
34956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34958 if (SWIG_arg_fail(1)) SWIG_fail;
34959 {
34960 arg2 = (int)(SWIG_As_int(obj1));
34961 if (SWIG_arg_fail(2)) SWIG_fail;
34962 }
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34966
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 {
34971 #if wxUSE_UNICODE
34972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34973 #else
34974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34975 #endif
34976 }
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34984 PyObject *resultobj;
34985 wxMenu *arg1 = (wxMenu *) 0 ;
34986 int arg2 ;
34987 wxString *arg3 = 0 ;
34988 bool temp3 = false ;
34989 PyObject * obj0 = 0 ;
34990 PyObject * obj1 = 0 ;
34991 PyObject * obj2 = 0 ;
34992 char *kwnames[] = {
34993 (char *) "self",(char *) "id",(char *) "helpString", NULL
34994 };
34995
34996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34998 if (SWIG_arg_fail(1)) SWIG_fail;
34999 {
35000 arg2 = (int)(SWIG_As_int(obj1));
35001 if (SWIG_arg_fail(2)) SWIG_fail;
35002 }
35003 {
35004 arg3 = wxString_in_helper(obj2);
35005 if (arg3 == NULL) SWIG_fail;
35006 temp3 = true;
35007 }
35008 {
35009 PyThreadState* __tstate = wxPyBeginAllowThreads();
35010 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35011
35012 wxPyEndAllowThreads(__tstate);
35013 if (PyErr_Occurred()) SWIG_fail;
35014 }
35015 Py_INCREF(Py_None); resultobj = Py_None;
35016 {
35017 if (temp3)
35018 delete arg3;
35019 }
35020 return resultobj;
35021 fail:
35022 {
35023 if (temp3)
35024 delete arg3;
35025 }
35026 return NULL;
35027 }
35028
35029
35030 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35031 PyObject *resultobj;
35032 wxMenu *arg1 = (wxMenu *) 0 ;
35033 int arg2 ;
35034 wxString result;
35035 PyObject * obj0 = 0 ;
35036 PyObject * obj1 = 0 ;
35037 char *kwnames[] = {
35038 (char *) "self",(char *) "id", NULL
35039 };
35040
35041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35043 if (SWIG_arg_fail(1)) SWIG_fail;
35044 {
35045 arg2 = (int)(SWIG_As_int(obj1));
35046 if (SWIG_arg_fail(2)) SWIG_fail;
35047 }
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35051
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 {
35056 #if wxUSE_UNICODE
35057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35058 #else
35059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35060 #endif
35061 }
35062 return resultobj;
35063 fail:
35064 return NULL;
35065 }
35066
35067
35068 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35069 PyObject *resultobj;
35070 wxMenu *arg1 = (wxMenu *) 0 ;
35071 wxString *arg2 = 0 ;
35072 bool temp2 = false ;
35073 PyObject * obj0 = 0 ;
35074 PyObject * obj1 = 0 ;
35075 char *kwnames[] = {
35076 (char *) "self",(char *) "title", NULL
35077 };
35078
35079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35081 if (SWIG_arg_fail(1)) SWIG_fail;
35082 {
35083 arg2 = wxString_in_helper(obj1);
35084 if (arg2 == NULL) SWIG_fail;
35085 temp2 = true;
35086 }
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 (arg1)->SetTitle((wxString const &)*arg2);
35090
35091 wxPyEndAllowThreads(__tstate);
35092 if (PyErr_Occurred()) SWIG_fail;
35093 }
35094 Py_INCREF(Py_None); resultobj = Py_None;
35095 {
35096 if (temp2)
35097 delete arg2;
35098 }
35099 return resultobj;
35100 fail:
35101 {
35102 if (temp2)
35103 delete arg2;
35104 }
35105 return NULL;
35106 }
35107
35108
35109 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj;
35111 wxMenu *arg1 = (wxMenu *) 0 ;
35112 wxString result;
35113 PyObject * obj0 = 0 ;
35114 char *kwnames[] = {
35115 (char *) "self", NULL
35116 };
35117
35118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35120 if (SWIG_arg_fail(1)) SWIG_fail;
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 result = ((wxMenu const *)arg1)->GetTitle();
35124
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 {
35129 #if wxUSE_UNICODE
35130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35131 #else
35132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35133 #endif
35134 }
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35142 PyObject *resultobj;
35143 wxMenu *arg1 = (wxMenu *) 0 ;
35144 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35145 PyObject * obj0 = 0 ;
35146 PyObject * obj1 = 0 ;
35147 char *kwnames[] = {
35148 (char *) "self",(char *) "handler", NULL
35149 };
35150
35151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35153 if (SWIG_arg_fail(1)) SWIG_fail;
35154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35155 if (SWIG_arg_fail(2)) SWIG_fail;
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 (arg1)->SetEventHandler(arg2);
35159
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 Py_INCREF(Py_None); resultobj = Py_None;
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35171 PyObject *resultobj;
35172 wxMenu *arg1 = (wxMenu *) 0 ;
35173 wxEvtHandler *result;
35174 PyObject * obj0 = 0 ;
35175 char *kwnames[] = {
35176 (char *) "self", NULL
35177 };
35178
35179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35181 if (SWIG_arg_fail(1)) SWIG_fail;
35182 {
35183 PyThreadState* __tstate = wxPyBeginAllowThreads();
35184 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35185
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 {
35190 resultobj = wxPyMake_wxObject(result, 0);
35191 }
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35199 PyObject *resultobj;
35200 wxMenu *arg1 = (wxMenu *) 0 ;
35201 wxWindow *arg2 = (wxWindow *) 0 ;
35202 PyObject * obj0 = 0 ;
35203 PyObject * obj1 = 0 ;
35204 char *kwnames[] = {
35205 (char *) "self",(char *) "win", NULL
35206 };
35207
35208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35210 if (SWIG_arg_fail(1)) SWIG_fail;
35211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35212 if (SWIG_arg_fail(2)) SWIG_fail;
35213 {
35214 PyThreadState* __tstate = wxPyBeginAllowThreads();
35215 (arg1)->SetInvokingWindow(arg2);
35216
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 Py_INCREF(Py_None); resultobj = Py_None;
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35228 PyObject *resultobj;
35229 wxMenu *arg1 = (wxMenu *) 0 ;
35230 wxWindow *result;
35231 PyObject * obj0 = 0 ;
35232 char *kwnames[] = {
35233 (char *) "self", NULL
35234 };
35235
35236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35238 if (SWIG_arg_fail(1)) SWIG_fail;
35239 {
35240 PyThreadState* __tstate = wxPyBeginAllowThreads();
35241 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35242
35243 wxPyEndAllowThreads(__tstate);
35244 if (PyErr_Occurred()) SWIG_fail;
35245 }
35246 {
35247 resultobj = wxPyMake_wxObject(result, 0);
35248 }
35249 return resultobj;
35250 fail:
35251 return NULL;
35252 }
35253
35254
35255 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35256 PyObject *resultobj;
35257 wxMenu *arg1 = (wxMenu *) 0 ;
35258 long result;
35259 PyObject * obj0 = 0 ;
35260 char *kwnames[] = {
35261 (char *) "self", NULL
35262 };
35263
35264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35266 if (SWIG_arg_fail(1)) SWIG_fail;
35267 {
35268 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 result = (long)((wxMenu const *)arg1)->GetStyle();
35270
35271 wxPyEndAllowThreads(__tstate);
35272 if (PyErr_Occurred()) SWIG_fail;
35273 }
35274 {
35275 resultobj = SWIG_From_long((long)(result));
35276 }
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35284 PyObject *resultobj;
35285 wxMenu *arg1 = (wxMenu *) 0 ;
35286 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35287 PyObject * obj0 = 0 ;
35288 PyObject * obj1 = 0 ;
35289 char *kwnames[] = {
35290 (char *) "self",(char *) "source", NULL
35291 };
35292
35293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35295 if (SWIG_arg_fail(1)) SWIG_fail;
35296 if (obj1) {
35297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35298 if (SWIG_arg_fail(2)) SWIG_fail;
35299 }
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 (arg1)->UpdateUI(arg2);
35303
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 Py_INCREF(Py_None); resultobj = Py_None;
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj;
35316 wxMenu *arg1 = (wxMenu *) 0 ;
35317 wxMenuBar *result;
35318 PyObject * obj0 = 0 ;
35319 char *kwnames[] = {
35320 (char *) "self", NULL
35321 };
35322
35323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35325 if (SWIG_arg_fail(1)) SWIG_fail;
35326 {
35327 PyThreadState* __tstate = wxPyBeginAllowThreads();
35328 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35329
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 {
35334 resultobj = wxPyMake_wxObject(result, 0);
35335 }
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35343 PyObject *resultobj;
35344 wxMenu *arg1 = (wxMenu *) 0 ;
35345 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35346 PyObject * obj0 = 0 ;
35347 PyObject * obj1 = 0 ;
35348 char *kwnames[] = {
35349 (char *) "self",(char *) "menubar", NULL
35350 };
35351
35352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35354 if (SWIG_arg_fail(1)) SWIG_fail;
35355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35356 if (SWIG_arg_fail(2)) SWIG_fail;
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 (arg1)->Attach(arg2);
35360
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 Py_INCREF(Py_None); resultobj = Py_None;
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35372 PyObject *resultobj;
35373 wxMenu *arg1 = (wxMenu *) 0 ;
35374 PyObject * obj0 = 0 ;
35375 char *kwnames[] = {
35376 (char *) "self", NULL
35377 };
35378
35379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35381 if (SWIG_arg_fail(1)) SWIG_fail;
35382 {
35383 PyThreadState* __tstate = wxPyBeginAllowThreads();
35384 (arg1)->Detach();
35385
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 Py_INCREF(Py_None); resultobj = Py_None;
35390 return resultobj;
35391 fail:
35392 return NULL;
35393 }
35394
35395
35396 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35397 PyObject *resultobj;
35398 wxMenu *arg1 = (wxMenu *) 0 ;
35399 bool result;
35400 PyObject * obj0 = 0 ;
35401 char *kwnames[] = {
35402 (char *) "self", NULL
35403 };
35404
35405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35407 if (SWIG_arg_fail(1)) SWIG_fail;
35408 {
35409 PyThreadState* __tstate = wxPyBeginAllowThreads();
35410 result = (bool)((wxMenu const *)arg1)->IsAttached();
35411
35412 wxPyEndAllowThreads(__tstate);
35413 if (PyErr_Occurred()) SWIG_fail;
35414 }
35415 {
35416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35417 }
35418 return resultobj;
35419 fail:
35420 return NULL;
35421 }
35422
35423
35424 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35425 PyObject *resultobj;
35426 wxMenu *arg1 = (wxMenu *) 0 ;
35427 wxMenu *arg2 = (wxMenu *) 0 ;
35428 PyObject * obj0 = 0 ;
35429 PyObject * obj1 = 0 ;
35430 char *kwnames[] = {
35431 (char *) "self",(char *) "parent", NULL
35432 };
35433
35434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35436 if (SWIG_arg_fail(1)) SWIG_fail;
35437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35438 if (SWIG_arg_fail(2)) SWIG_fail;
35439 {
35440 PyThreadState* __tstate = wxPyBeginAllowThreads();
35441 (arg1)->SetParent(arg2);
35442
35443 wxPyEndAllowThreads(__tstate);
35444 if (PyErr_Occurred()) SWIG_fail;
35445 }
35446 Py_INCREF(Py_None); resultobj = Py_None;
35447 return resultobj;
35448 fail:
35449 return NULL;
35450 }
35451
35452
35453 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35454 PyObject *resultobj;
35455 wxMenu *arg1 = (wxMenu *) 0 ;
35456 wxMenu *result;
35457 PyObject * obj0 = 0 ;
35458 char *kwnames[] = {
35459 (char *) "self", NULL
35460 };
35461
35462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35464 if (SWIG_arg_fail(1)) SWIG_fail;
35465 {
35466 PyThreadState* __tstate = wxPyBeginAllowThreads();
35467 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35468
35469 wxPyEndAllowThreads(__tstate);
35470 if (PyErr_Occurred()) SWIG_fail;
35471 }
35472 {
35473 resultobj = wxPyMake_wxObject(result, 0);
35474 }
35475 return resultobj;
35476 fail:
35477 return NULL;
35478 }
35479
35480
35481 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35482 PyObject *obj;
35483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35484 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35485 Py_INCREF(obj);
35486 return Py_BuildValue((char *)"");
35487 }
35488 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj;
35490 long arg1 = (long) 0 ;
35491 wxMenuBar *result;
35492 PyObject * obj0 = 0 ;
35493 char *kwnames[] = {
35494 (char *) "style", NULL
35495 };
35496
35497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35498 if (obj0) {
35499 {
35500 arg1 = (long)(SWIG_As_long(obj0));
35501 if (SWIG_arg_fail(1)) SWIG_fail;
35502 }
35503 }
35504 {
35505 if (!wxPyCheckForApp()) SWIG_fail;
35506 PyThreadState* __tstate = wxPyBeginAllowThreads();
35507 result = (wxMenuBar *)new wxMenuBar(arg1);
35508
35509 wxPyEndAllowThreads(__tstate);
35510 if (PyErr_Occurred()) SWIG_fail;
35511 }
35512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj;
35521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35522 wxMenu *arg2 = (wxMenu *) 0 ;
35523 wxString *arg3 = 0 ;
35524 bool result;
35525 bool temp3 = false ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 PyObject * obj2 = 0 ;
35529 char *kwnames[] = {
35530 (char *) "self",(char *) "menu",(char *) "title", NULL
35531 };
35532
35533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35535 if (SWIG_arg_fail(1)) SWIG_fail;
35536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35537 if (SWIG_arg_fail(2)) SWIG_fail;
35538 {
35539 arg3 = wxString_in_helper(obj2);
35540 if (arg3 == NULL) SWIG_fail;
35541 temp3 = true;
35542 }
35543 {
35544 PyThreadState* __tstate = wxPyBeginAllowThreads();
35545 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35546
35547 wxPyEndAllowThreads(__tstate);
35548 if (PyErr_Occurred()) SWIG_fail;
35549 }
35550 {
35551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35552 }
35553 {
35554 if (temp3)
35555 delete arg3;
35556 }
35557 return resultobj;
35558 fail:
35559 {
35560 if (temp3)
35561 delete arg3;
35562 }
35563 return NULL;
35564 }
35565
35566
35567 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35568 PyObject *resultobj;
35569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35570 size_t arg2 ;
35571 wxMenu *arg3 = (wxMenu *) 0 ;
35572 wxString *arg4 = 0 ;
35573 bool result;
35574 bool temp4 = false ;
35575 PyObject * obj0 = 0 ;
35576 PyObject * obj1 = 0 ;
35577 PyObject * obj2 = 0 ;
35578 PyObject * obj3 = 0 ;
35579 char *kwnames[] = {
35580 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35581 };
35582
35583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35585 if (SWIG_arg_fail(1)) SWIG_fail;
35586 {
35587 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35588 if (SWIG_arg_fail(2)) SWIG_fail;
35589 }
35590 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35591 if (SWIG_arg_fail(3)) SWIG_fail;
35592 {
35593 arg4 = wxString_in_helper(obj3);
35594 if (arg4 == NULL) SWIG_fail;
35595 temp4 = true;
35596 }
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35600
35601 wxPyEndAllowThreads(__tstate);
35602 if (PyErr_Occurred()) SWIG_fail;
35603 }
35604 {
35605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35606 }
35607 {
35608 if (temp4)
35609 delete arg4;
35610 }
35611 return resultobj;
35612 fail:
35613 {
35614 if (temp4)
35615 delete arg4;
35616 }
35617 return NULL;
35618 }
35619
35620
35621 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35622 PyObject *resultobj;
35623 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35624 size_t result;
35625 PyObject * obj0 = 0 ;
35626 char *kwnames[] = {
35627 (char *) "self", NULL
35628 };
35629
35630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35632 if (SWIG_arg_fail(1)) SWIG_fail;
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35636
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 {
35641 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35642 }
35643 return resultobj;
35644 fail:
35645 return NULL;
35646 }
35647
35648
35649 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35650 PyObject *resultobj;
35651 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35652 size_t arg2 ;
35653 wxMenu *result;
35654 PyObject * obj0 = 0 ;
35655 PyObject * obj1 = 0 ;
35656 char *kwnames[] = {
35657 (char *) "self",(char *) "pos", NULL
35658 };
35659
35660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35662 if (SWIG_arg_fail(1)) SWIG_fail;
35663 {
35664 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35665 if (SWIG_arg_fail(2)) SWIG_fail;
35666 }
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35670
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 {
35675 resultobj = wxPyMake_wxObject(result, 0);
35676 }
35677 return resultobj;
35678 fail:
35679 return NULL;
35680 }
35681
35682
35683 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj;
35685 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35686 size_t arg2 ;
35687 wxMenu *arg3 = (wxMenu *) 0 ;
35688 wxString *arg4 = 0 ;
35689 wxMenu *result;
35690 bool temp4 = false ;
35691 PyObject * obj0 = 0 ;
35692 PyObject * obj1 = 0 ;
35693 PyObject * obj2 = 0 ;
35694 PyObject * obj3 = 0 ;
35695 char *kwnames[] = {
35696 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35697 };
35698
35699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35701 if (SWIG_arg_fail(1)) SWIG_fail;
35702 {
35703 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35704 if (SWIG_arg_fail(2)) SWIG_fail;
35705 }
35706 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35707 if (SWIG_arg_fail(3)) SWIG_fail;
35708 {
35709 arg4 = wxString_in_helper(obj3);
35710 if (arg4 == NULL) SWIG_fail;
35711 temp4 = true;
35712 }
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 {
35721 resultobj = wxPyMake_wxObject(result, 0);
35722 }
35723 {
35724 if (temp4)
35725 delete arg4;
35726 }
35727 return resultobj;
35728 fail:
35729 {
35730 if (temp4)
35731 delete arg4;
35732 }
35733 return NULL;
35734 }
35735
35736
35737 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35738 PyObject *resultobj;
35739 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35740 size_t arg2 ;
35741 wxMenu *result;
35742 PyObject * obj0 = 0 ;
35743 PyObject * obj1 = 0 ;
35744 char *kwnames[] = {
35745 (char *) "self",(char *) "pos", NULL
35746 };
35747
35748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35750 if (SWIG_arg_fail(1)) SWIG_fail;
35751 {
35752 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35753 if (SWIG_arg_fail(2)) SWIG_fail;
35754 }
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (wxMenu *)(arg1)->Remove(arg2);
35758
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 {
35763 resultobj = wxPyMake_wxObject(result, 0);
35764 }
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj;
35773 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35774 size_t arg2 ;
35775 bool arg3 ;
35776 PyObject * obj0 = 0 ;
35777 PyObject * obj1 = 0 ;
35778 PyObject * obj2 = 0 ;
35779 char *kwnames[] = {
35780 (char *) "self",(char *) "pos",(char *) "enable", NULL
35781 };
35782
35783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35785 if (SWIG_arg_fail(1)) SWIG_fail;
35786 {
35787 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35788 if (SWIG_arg_fail(2)) SWIG_fail;
35789 }
35790 {
35791 arg3 = (bool)(SWIG_As_bool(obj2));
35792 if (SWIG_arg_fail(3)) SWIG_fail;
35793 }
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 (arg1)->EnableTop(arg2,arg3);
35797
35798 wxPyEndAllowThreads(__tstate);
35799 if (PyErr_Occurred()) SWIG_fail;
35800 }
35801 Py_INCREF(Py_None); resultobj = Py_None;
35802 return resultobj;
35803 fail:
35804 return NULL;
35805 }
35806
35807
35808 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35809 PyObject *resultobj;
35810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35811 size_t arg2 ;
35812 bool result;
35813 PyObject * obj0 = 0 ;
35814 PyObject * obj1 = 0 ;
35815 char *kwnames[] = {
35816 (char *) "self",(char *) "pos", NULL
35817 };
35818
35819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35821 if (SWIG_arg_fail(1)) SWIG_fail;
35822 {
35823 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35824 if (SWIG_arg_fail(2)) SWIG_fail;
35825 }
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35829
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 {
35834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35835 }
35836 return resultobj;
35837 fail:
35838 return NULL;
35839 }
35840
35841
35842 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35843 PyObject *resultobj;
35844 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35845 size_t arg2 ;
35846 wxString *arg3 = 0 ;
35847 bool temp3 = false ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 PyObject * obj2 = 0 ;
35851 char *kwnames[] = {
35852 (char *) "self",(char *) "pos",(char *) "label", NULL
35853 };
35854
35855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35857 if (SWIG_arg_fail(1)) SWIG_fail;
35858 {
35859 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35860 if (SWIG_arg_fail(2)) SWIG_fail;
35861 }
35862 {
35863 arg3 = wxString_in_helper(obj2);
35864 if (arg3 == NULL) SWIG_fail;
35865 temp3 = true;
35866 }
35867 {
35868 PyThreadState* __tstate = wxPyBeginAllowThreads();
35869 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35870
35871 wxPyEndAllowThreads(__tstate);
35872 if (PyErr_Occurred()) SWIG_fail;
35873 }
35874 Py_INCREF(Py_None); resultobj = Py_None;
35875 {
35876 if (temp3)
35877 delete arg3;
35878 }
35879 return resultobj;
35880 fail:
35881 {
35882 if (temp3)
35883 delete arg3;
35884 }
35885 return NULL;
35886 }
35887
35888
35889 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35890 PyObject *resultobj;
35891 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35892 size_t arg2 ;
35893 wxString result;
35894 PyObject * obj0 = 0 ;
35895 PyObject * obj1 = 0 ;
35896 char *kwnames[] = {
35897 (char *) "self",(char *) "pos", NULL
35898 };
35899
35900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35902 if (SWIG_arg_fail(1)) SWIG_fail;
35903 {
35904 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35905 if (SWIG_arg_fail(2)) SWIG_fail;
35906 }
35907 {
35908 PyThreadState* __tstate = wxPyBeginAllowThreads();
35909 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35910
35911 wxPyEndAllowThreads(__tstate);
35912 if (PyErr_Occurred()) SWIG_fail;
35913 }
35914 {
35915 #if wxUSE_UNICODE
35916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35917 #else
35918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35919 #endif
35920 }
35921 return resultobj;
35922 fail:
35923 return NULL;
35924 }
35925
35926
35927 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35928 PyObject *resultobj;
35929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35930 wxString *arg2 = 0 ;
35931 wxString *arg3 = 0 ;
35932 int result;
35933 bool temp2 = false ;
35934 bool temp3 = false ;
35935 PyObject * obj0 = 0 ;
35936 PyObject * obj1 = 0 ;
35937 PyObject * obj2 = 0 ;
35938 char *kwnames[] = {
35939 (char *) "self",(char *) "menu",(char *) "item", NULL
35940 };
35941
35942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35944 if (SWIG_arg_fail(1)) SWIG_fail;
35945 {
35946 arg2 = wxString_in_helper(obj1);
35947 if (arg2 == NULL) SWIG_fail;
35948 temp2 = true;
35949 }
35950 {
35951 arg3 = wxString_in_helper(obj2);
35952 if (arg3 == NULL) SWIG_fail;
35953 temp3 = true;
35954 }
35955 {
35956 PyThreadState* __tstate = wxPyBeginAllowThreads();
35957 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35958
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 {
35963 resultobj = SWIG_From_int((int)(result));
35964 }
35965 {
35966 if (temp2)
35967 delete arg2;
35968 }
35969 {
35970 if (temp3)
35971 delete arg3;
35972 }
35973 return resultobj;
35974 fail:
35975 {
35976 if (temp2)
35977 delete arg2;
35978 }
35979 {
35980 if (temp3)
35981 delete arg3;
35982 }
35983 return NULL;
35984 }
35985
35986
35987 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35988 PyObject *resultobj;
35989 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35990 int arg2 ;
35991 wxMenuItem *result;
35992 PyObject * obj0 = 0 ;
35993 PyObject * obj1 = 0 ;
35994 char *kwnames[] = {
35995 (char *) "self",(char *) "id", NULL
35996 };
35997
35998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36000 if (SWIG_arg_fail(1)) SWIG_fail;
36001 {
36002 arg2 = (int)(SWIG_As_int(obj1));
36003 if (SWIG_arg_fail(2)) SWIG_fail;
36004 }
36005 {
36006 PyThreadState* __tstate = wxPyBeginAllowThreads();
36007 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36008
36009 wxPyEndAllowThreads(__tstate);
36010 if (PyErr_Occurred()) SWIG_fail;
36011 }
36012 {
36013 resultobj = wxPyMake_wxObject(result, 0);
36014 }
36015 return resultobj;
36016 fail:
36017 return NULL;
36018 }
36019
36020
36021 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36022 PyObject *resultobj;
36023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36024 wxString *arg2 = 0 ;
36025 int result;
36026 bool temp2 = false ;
36027 PyObject * obj0 = 0 ;
36028 PyObject * obj1 = 0 ;
36029 char *kwnames[] = {
36030 (char *) "self",(char *) "title", NULL
36031 };
36032
36033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36035 if (SWIG_arg_fail(1)) SWIG_fail;
36036 {
36037 arg2 = wxString_in_helper(obj1);
36038 if (arg2 == NULL) SWIG_fail;
36039 temp2 = true;
36040 }
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36044
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 resultobj = SWIG_From_int((int)(result));
36050 }
36051 {
36052 if (temp2)
36053 delete arg2;
36054 }
36055 return resultobj;
36056 fail:
36057 {
36058 if (temp2)
36059 delete arg2;
36060 }
36061 return NULL;
36062 }
36063
36064
36065 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36066 PyObject *resultobj;
36067 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36068 int arg2 ;
36069 bool arg3 ;
36070 PyObject * obj0 = 0 ;
36071 PyObject * obj1 = 0 ;
36072 PyObject * obj2 = 0 ;
36073 char *kwnames[] = {
36074 (char *) "self",(char *) "id",(char *) "enable", NULL
36075 };
36076
36077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36079 if (SWIG_arg_fail(1)) SWIG_fail;
36080 {
36081 arg2 = (int)(SWIG_As_int(obj1));
36082 if (SWIG_arg_fail(2)) SWIG_fail;
36083 }
36084 {
36085 arg3 = (bool)(SWIG_As_bool(obj2));
36086 if (SWIG_arg_fail(3)) SWIG_fail;
36087 }
36088 {
36089 PyThreadState* __tstate = wxPyBeginAllowThreads();
36090 (arg1)->Enable(arg2,arg3);
36091
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 Py_INCREF(Py_None); resultobj = Py_None;
36096 return resultobj;
36097 fail:
36098 return NULL;
36099 }
36100
36101
36102 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36103 PyObject *resultobj;
36104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36105 int arg2 ;
36106 bool arg3 ;
36107 PyObject * obj0 = 0 ;
36108 PyObject * obj1 = 0 ;
36109 PyObject * obj2 = 0 ;
36110 char *kwnames[] = {
36111 (char *) "self",(char *) "id",(char *) "check", NULL
36112 };
36113
36114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36116 if (SWIG_arg_fail(1)) SWIG_fail;
36117 {
36118 arg2 = (int)(SWIG_As_int(obj1));
36119 if (SWIG_arg_fail(2)) SWIG_fail;
36120 }
36121 {
36122 arg3 = (bool)(SWIG_As_bool(obj2));
36123 if (SWIG_arg_fail(3)) SWIG_fail;
36124 }
36125 {
36126 PyThreadState* __tstate = wxPyBeginAllowThreads();
36127 (arg1)->Check(arg2,arg3);
36128
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 Py_INCREF(Py_None); resultobj = Py_None;
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36140 PyObject *resultobj;
36141 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36142 int arg2 ;
36143 bool result;
36144 PyObject * obj0 = 0 ;
36145 PyObject * obj1 = 0 ;
36146 char *kwnames[] = {
36147 (char *) "self",(char *) "id", NULL
36148 };
36149
36150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36152 if (SWIG_arg_fail(1)) SWIG_fail;
36153 {
36154 arg2 = (int)(SWIG_As_int(obj1));
36155 if (SWIG_arg_fail(2)) SWIG_fail;
36156 }
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36160
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 {
36165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj;
36175 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36176 int arg2 ;
36177 bool result;
36178 PyObject * obj0 = 0 ;
36179 PyObject * obj1 = 0 ;
36180 char *kwnames[] = {
36181 (char *) "self",(char *) "id", NULL
36182 };
36183
36184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36186 if (SWIG_arg_fail(1)) SWIG_fail;
36187 {
36188 arg2 = (int)(SWIG_As_int(obj1));
36189 if (SWIG_arg_fail(2)) SWIG_fail;
36190 }
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36194
36195 wxPyEndAllowThreads(__tstate);
36196 if (PyErr_Occurred()) SWIG_fail;
36197 }
36198 {
36199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36200 }
36201 return resultobj;
36202 fail:
36203 return NULL;
36204 }
36205
36206
36207 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36208 PyObject *resultobj;
36209 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36210 int arg2 ;
36211 wxString *arg3 = 0 ;
36212 bool temp3 = false ;
36213 PyObject * obj0 = 0 ;
36214 PyObject * obj1 = 0 ;
36215 PyObject * obj2 = 0 ;
36216 char *kwnames[] = {
36217 (char *) "self",(char *) "id",(char *) "label", NULL
36218 };
36219
36220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36222 if (SWIG_arg_fail(1)) SWIG_fail;
36223 {
36224 arg2 = (int)(SWIG_As_int(obj1));
36225 if (SWIG_arg_fail(2)) SWIG_fail;
36226 }
36227 {
36228 arg3 = wxString_in_helper(obj2);
36229 if (arg3 == NULL) SWIG_fail;
36230 temp3 = true;
36231 }
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36235
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 Py_INCREF(Py_None); resultobj = Py_None;
36240 {
36241 if (temp3)
36242 delete arg3;
36243 }
36244 return resultobj;
36245 fail:
36246 {
36247 if (temp3)
36248 delete arg3;
36249 }
36250 return NULL;
36251 }
36252
36253
36254 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36255 PyObject *resultobj;
36256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36257 int arg2 ;
36258 wxString result;
36259 PyObject * obj0 = 0 ;
36260 PyObject * obj1 = 0 ;
36261 char *kwnames[] = {
36262 (char *) "self",(char *) "id", NULL
36263 };
36264
36265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36267 if (SWIG_arg_fail(1)) SWIG_fail;
36268 {
36269 arg2 = (int)(SWIG_As_int(obj1));
36270 if (SWIG_arg_fail(2)) SWIG_fail;
36271 }
36272 {
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36275
36276 wxPyEndAllowThreads(__tstate);
36277 if (PyErr_Occurred()) SWIG_fail;
36278 }
36279 {
36280 #if wxUSE_UNICODE
36281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36282 #else
36283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36284 #endif
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36293 PyObject *resultobj;
36294 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36295 int arg2 ;
36296 wxString *arg3 = 0 ;
36297 bool temp3 = false ;
36298 PyObject * obj0 = 0 ;
36299 PyObject * obj1 = 0 ;
36300 PyObject * obj2 = 0 ;
36301 char *kwnames[] = {
36302 (char *) "self",(char *) "id",(char *) "helpString", NULL
36303 };
36304
36305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36307 if (SWIG_arg_fail(1)) SWIG_fail;
36308 {
36309 arg2 = (int)(SWIG_As_int(obj1));
36310 if (SWIG_arg_fail(2)) SWIG_fail;
36311 }
36312 {
36313 arg3 = wxString_in_helper(obj2);
36314 if (arg3 == NULL) SWIG_fail;
36315 temp3 = true;
36316 }
36317 {
36318 PyThreadState* __tstate = wxPyBeginAllowThreads();
36319 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36320
36321 wxPyEndAllowThreads(__tstate);
36322 if (PyErr_Occurred()) SWIG_fail;
36323 }
36324 Py_INCREF(Py_None); resultobj = Py_None;
36325 {
36326 if (temp3)
36327 delete arg3;
36328 }
36329 return resultobj;
36330 fail:
36331 {
36332 if (temp3)
36333 delete arg3;
36334 }
36335 return NULL;
36336 }
36337
36338
36339 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36340 PyObject *resultobj;
36341 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36342 int arg2 ;
36343 wxString result;
36344 PyObject * obj0 = 0 ;
36345 PyObject * obj1 = 0 ;
36346 char *kwnames[] = {
36347 (char *) "self",(char *) "id", NULL
36348 };
36349
36350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36352 if (SWIG_arg_fail(1)) SWIG_fail;
36353 {
36354 arg2 = (int)(SWIG_As_int(obj1));
36355 if (SWIG_arg_fail(2)) SWIG_fail;
36356 }
36357 {
36358 PyThreadState* __tstate = wxPyBeginAllowThreads();
36359 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36360
36361 wxPyEndAllowThreads(__tstate);
36362 if (PyErr_Occurred()) SWIG_fail;
36363 }
36364 {
36365 #if wxUSE_UNICODE
36366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36367 #else
36368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36369 #endif
36370 }
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj;
36379 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36380 wxFrame *result;
36381 PyObject * obj0 = 0 ;
36382 char *kwnames[] = {
36383 (char *) "self", NULL
36384 };
36385
36386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36388 if (SWIG_arg_fail(1)) SWIG_fail;
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36392
36393 wxPyEndAllowThreads(__tstate);
36394 if (PyErr_Occurred()) SWIG_fail;
36395 }
36396 {
36397 resultobj = wxPyMake_wxObject(result, 0);
36398 }
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36406 PyObject *resultobj;
36407 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36408 bool result;
36409 PyObject * obj0 = 0 ;
36410 char *kwnames[] = {
36411 (char *) "self", NULL
36412 };
36413
36414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36416 if (SWIG_arg_fail(1)) SWIG_fail;
36417 {
36418 PyThreadState* __tstate = wxPyBeginAllowThreads();
36419 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36420
36421 wxPyEndAllowThreads(__tstate);
36422 if (PyErr_Occurred()) SWIG_fail;
36423 }
36424 {
36425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36426 }
36427 return resultobj;
36428 fail:
36429 return NULL;
36430 }
36431
36432
36433 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36434 PyObject *resultobj;
36435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36436 wxFrame *arg2 = (wxFrame *) 0 ;
36437 PyObject * obj0 = 0 ;
36438 PyObject * obj1 = 0 ;
36439 char *kwnames[] = {
36440 (char *) "self",(char *) "frame", NULL
36441 };
36442
36443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36445 if (SWIG_arg_fail(1)) SWIG_fail;
36446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36447 if (SWIG_arg_fail(2)) SWIG_fail;
36448 {
36449 PyThreadState* __tstate = wxPyBeginAllowThreads();
36450 (arg1)->Attach(arg2);
36451
36452 wxPyEndAllowThreads(__tstate);
36453 if (PyErr_Occurred()) SWIG_fail;
36454 }
36455 Py_INCREF(Py_None); resultobj = Py_None;
36456 return resultobj;
36457 fail:
36458 return NULL;
36459 }
36460
36461
36462 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36463 PyObject *resultobj;
36464 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36465 PyObject * obj0 = 0 ;
36466 char *kwnames[] = {
36467 (char *) "self", NULL
36468 };
36469
36470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36472 if (SWIG_arg_fail(1)) SWIG_fail;
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 (arg1)->Detach();
36476
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 Py_INCREF(Py_None); resultobj = Py_None;
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 bool arg1 ;
36490 PyObject * obj0 = 0 ;
36491 char *kwnames[] = {
36492 (char *) "enable", NULL
36493 };
36494
36495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36496 {
36497 arg1 = (bool)(SWIG_As_bool(obj0));
36498 if (SWIG_arg_fail(1)) SWIG_fail;
36499 }
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 wxMenuBar::SetAutoWindowMenu(arg1);
36503
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 Py_INCREF(Py_None); resultobj = Py_None;
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj;
36516 bool result;
36517 char *kwnames[] = {
36518 NULL
36519 };
36520
36521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 result = (bool)wxMenuBar::GetAutoWindowMenu();
36525
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 {
36530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36531 }
36532 return resultobj;
36533 fail:
36534 return NULL;
36535 }
36536
36537
36538 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36539 PyObject *obj;
36540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36541 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36542 Py_INCREF(obj);
36543 return Py_BuildValue((char *)"");
36544 }
36545 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36546 PyObject *resultobj;
36547 wxMenu *arg1 = (wxMenu *) NULL ;
36548 int arg2 = (int) wxID_ANY ;
36549 wxString const &arg3_defvalue = wxPyEmptyString ;
36550 wxString *arg3 = (wxString *) &arg3_defvalue ;
36551 wxString const &arg4_defvalue = wxPyEmptyString ;
36552 wxString *arg4 = (wxString *) &arg4_defvalue ;
36553 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36554 wxMenu *arg6 = (wxMenu *) NULL ;
36555 wxMenuItem *result;
36556 bool temp3 = false ;
36557 bool temp4 = false ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 PyObject * obj2 = 0 ;
36561 PyObject * obj3 = 0 ;
36562 PyObject * obj4 = 0 ;
36563 PyObject * obj5 = 0 ;
36564 char *kwnames[] = {
36565 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36566 };
36567
36568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36569 if (obj0) {
36570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36571 if (SWIG_arg_fail(1)) SWIG_fail;
36572 }
36573 if (obj1) {
36574 {
36575 arg2 = (int)(SWIG_As_int(obj1));
36576 if (SWIG_arg_fail(2)) SWIG_fail;
36577 }
36578 }
36579 if (obj2) {
36580 {
36581 arg3 = wxString_in_helper(obj2);
36582 if (arg3 == NULL) SWIG_fail;
36583 temp3 = true;
36584 }
36585 }
36586 if (obj3) {
36587 {
36588 arg4 = wxString_in_helper(obj3);
36589 if (arg4 == NULL) SWIG_fail;
36590 temp4 = true;
36591 }
36592 }
36593 if (obj4) {
36594 {
36595 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36596 if (SWIG_arg_fail(5)) SWIG_fail;
36597 }
36598 }
36599 if (obj5) {
36600 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36601 if (SWIG_arg_fail(6)) SWIG_fail;
36602 }
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36606
36607 wxPyEndAllowThreads(__tstate);
36608 if (PyErr_Occurred()) SWIG_fail;
36609 }
36610 {
36611 resultobj = wxPyMake_wxObject(result, 1);
36612 }
36613 {
36614 if (temp3)
36615 delete arg3;
36616 }
36617 {
36618 if (temp4)
36619 delete arg4;
36620 }
36621 return resultobj;
36622 fail:
36623 {
36624 if (temp3)
36625 delete arg3;
36626 }
36627 {
36628 if (temp4)
36629 delete arg4;
36630 }
36631 return NULL;
36632 }
36633
36634
36635 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj;
36637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36638 wxMenu *result;
36639 PyObject * obj0 = 0 ;
36640 char *kwnames[] = {
36641 (char *) "self", NULL
36642 };
36643
36644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36646 if (SWIG_arg_fail(1)) SWIG_fail;
36647 {
36648 PyThreadState* __tstate = wxPyBeginAllowThreads();
36649 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36650
36651 wxPyEndAllowThreads(__tstate);
36652 if (PyErr_Occurred()) SWIG_fail;
36653 }
36654 {
36655 resultobj = wxPyMake_wxObject(result, 0);
36656 }
36657 return resultobj;
36658 fail:
36659 return NULL;
36660 }
36661
36662
36663 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36664 PyObject *resultobj;
36665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36666 wxMenu *arg2 = (wxMenu *) 0 ;
36667 PyObject * obj0 = 0 ;
36668 PyObject * obj1 = 0 ;
36669 char *kwnames[] = {
36670 (char *) "self",(char *) "menu", NULL
36671 };
36672
36673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36675 if (SWIG_arg_fail(1)) SWIG_fail;
36676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36677 if (SWIG_arg_fail(2)) SWIG_fail;
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 (arg1)->SetMenu(arg2);
36681
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 Py_INCREF(Py_None); resultobj = Py_None;
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36693 PyObject *resultobj;
36694 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36695 int arg2 ;
36696 PyObject * obj0 = 0 ;
36697 PyObject * obj1 = 0 ;
36698 char *kwnames[] = {
36699 (char *) "self",(char *) "id", NULL
36700 };
36701
36702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36704 if (SWIG_arg_fail(1)) SWIG_fail;
36705 {
36706 arg2 = (int)(SWIG_As_int(obj1));
36707 if (SWIG_arg_fail(2)) SWIG_fail;
36708 }
36709 {
36710 PyThreadState* __tstate = wxPyBeginAllowThreads();
36711 (arg1)->SetId(arg2);
36712
36713 wxPyEndAllowThreads(__tstate);
36714 if (PyErr_Occurred()) SWIG_fail;
36715 }
36716 Py_INCREF(Py_None); resultobj = Py_None;
36717 return resultobj;
36718 fail:
36719 return NULL;
36720 }
36721
36722
36723 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj;
36725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36726 int result;
36727 PyObject * obj0 = 0 ;
36728 char *kwnames[] = {
36729 (char *) "self", NULL
36730 };
36731
36732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36734 if (SWIG_arg_fail(1)) SWIG_fail;
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (int)((wxMenuItem const *)arg1)->GetId();
36738
36739 wxPyEndAllowThreads(__tstate);
36740 if (PyErr_Occurred()) SWIG_fail;
36741 }
36742 {
36743 resultobj = SWIG_From_int((int)(result));
36744 }
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36752 PyObject *resultobj;
36753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36754 bool result;
36755 PyObject * obj0 = 0 ;
36756 char *kwnames[] = {
36757 (char *) "self", NULL
36758 };
36759
36760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36762 if (SWIG_arg_fail(1)) SWIG_fail;
36763 {
36764 PyThreadState* __tstate = wxPyBeginAllowThreads();
36765 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36766
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 {
36771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36772 }
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj;
36781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36782 wxString *arg2 = 0 ;
36783 bool temp2 = false ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 char *kwnames[] = {
36787 (char *) "self",(char *) "str", NULL
36788 };
36789
36790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36792 if (SWIG_arg_fail(1)) SWIG_fail;
36793 {
36794 arg2 = wxString_in_helper(obj1);
36795 if (arg2 == NULL) SWIG_fail;
36796 temp2 = true;
36797 }
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 (arg1)->SetText((wxString const &)*arg2);
36801
36802 wxPyEndAllowThreads(__tstate);
36803 if (PyErr_Occurred()) SWIG_fail;
36804 }
36805 Py_INCREF(Py_None); resultobj = Py_None;
36806 {
36807 if (temp2)
36808 delete arg2;
36809 }
36810 return resultobj;
36811 fail:
36812 {
36813 if (temp2)
36814 delete arg2;
36815 }
36816 return NULL;
36817 }
36818
36819
36820 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36821 PyObject *resultobj;
36822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36823 wxString result;
36824 PyObject * obj0 = 0 ;
36825 char *kwnames[] = {
36826 (char *) "self", NULL
36827 };
36828
36829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36831 if (SWIG_arg_fail(1)) SWIG_fail;
36832 {
36833 PyThreadState* __tstate = wxPyBeginAllowThreads();
36834 result = ((wxMenuItem const *)arg1)->GetLabel();
36835
36836 wxPyEndAllowThreads(__tstate);
36837 if (PyErr_Occurred()) SWIG_fail;
36838 }
36839 {
36840 #if wxUSE_UNICODE
36841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36842 #else
36843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36844 #endif
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj;
36854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36855 wxString *result;
36856 PyObject * obj0 = 0 ;
36857 char *kwnames[] = {
36858 (char *) "self", NULL
36859 };
36860
36861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36863 if (SWIG_arg_fail(1)) SWIG_fail;
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 {
36867 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36868 result = (wxString *) &_result_ref;
36869 }
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_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36888 PyObject *resultobj;
36889 wxString *arg1 = 0 ;
36890 wxString result;
36891 bool temp1 = false ;
36892 PyObject * obj0 = 0 ;
36893 char *kwnames[] = {
36894 (char *) "text", NULL
36895 };
36896
36897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36898 {
36899 arg1 = wxString_in_helper(obj0);
36900 if (arg1 == NULL) SWIG_fail;
36901 temp1 = true;
36902 }
36903 {
36904 PyThreadState* __tstate = wxPyBeginAllowThreads();
36905 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36906
36907 wxPyEndAllowThreads(__tstate);
36908 if (PyErr_Occurred()) SWIG_fail;
36909 }
36910 {
36911 #if wxUSE_UNICODE
36912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36913 #else
36914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36915 #endif
36916 }
36917 {
36918 if (temp1)
36919 delete arg1;
36920 }
36921 return resultobj;
36922 fail:
36923 {
36924 if (temp1)
36925 delete arg1;
36926 }
36927 return NULL;
36928 }
36929
36930
36931 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj;
36933 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36934 wxItemKind result;
36935 PyObject * obj0 = 0 ;
36936 char *kwnames[] = {
36937 (char *) "self", NULL
36938 };
36939
36940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36942 if (SWIG_arg_fail(1)) SWIG_fail;
36943 {
36944 PyThreadState* __tstate = wxPyBeginAllowThreads();
36945 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36946
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 resultobj = SWIG_From_int((result));
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj;
36959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36960 wxItemKind arg2 ;
36961 PyObject * obj0 = 0 ;
36962 PyObject * obj1 = 0 ;
36963 char *kwnames[] = {
36964 (char *) "self",(char *) "kind", NULL
36965 };
36966
36967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36969 if (SWIG_arg_fail(1)) SWIG_fail;
36970 {
36971 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36972 if (SWIG_arg_fail(2)) SWIG_fail;
36973 }
36974 {
36975 PyThreadState* __tstate = wxPyBeginAllowThreads();
36976 (arg1)->SetKind((wxItemKind )arg2);
36977
36978 wxPyEndAllowThreads(__tstate);
36979 if (PyErr_Occurred()) SWIG_fail;
36980 }
36981 Py_INCREF(Py_None); resultobj = Py_None;
36982 return resultobj;
36983 fail:
36984 return NULL;
36985 }
36986
36987
36988 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36989 PyObject *resultobj;
36990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36991 bool arg2 ;
36992 PyObject * obj0 = 0 ;
36993 PyObject * obj1 = 0 ;
36994 char *kwnames[] = {
36995 (char *) "self",(char *) "checkable", NULL
36996 };
36997
36998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37000 if (SWIG_arg_fail(1)) SWIG_fail;
37001 {
37002 arg2 = (bool)(SWIG_As_bool(obj1));
37003 if (SWIG_arg_fail(2)) SWIG_fail;
37004 }
37005 {
37006 PyThreadState* __tstate = wxPyBeginAllowThreads();
37007 (arg1)->SetCheckable(arg2);
37008
37009 wxPyEndAllowThreads(__tstate);
37010 if (PyErr_Occurred()) SWIG_fail;
37011 }
37012 Py_INCREF(Py_None); resultobj = Py_None;
37013 return resultobj;
37014 fail:
37015 return NULL;
37016 }
37017
37018
37019 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37020 PyObject *resultobj;
37021 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37022 bool result;
37023 PyObject * obj0 = 0 ;
37024 char *kwnames[] = {
37025 (char *) "self", NULL
37026 };
37027
37028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37030 if (SWIG_arg_fail(1)) SWIG_fail;
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37034
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 {
37039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37040 }
37041 return resultobj;
37042 fail:
37043 return NULL;
37044 }
37045
37046
37047 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37048 PyObject *resultobj;
37049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37050 bool result;
37051 PyObject * obj0 = 0 ;
37052 char *kwnames[] = {
37053 (char *) "self", NULL
37054 };
37055
37056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37058 if (SWIG_arg_fail(1)) SWIG_fail;
37059 {
37060 PyThreadState* __tstate = wxPyBeginAllowThreads();
37061 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37062
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 {
37067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37068 }
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37076 PyObject *resultobj;
37077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37078 wxMenu *arg2 = (wxMenu *) 0 ;
37079 PyObject * obj0 = 0 ;
37080 PyObject * obj1 = 0 ;
37081 char *kwnames[] = {
37082 (char *) "self",(char *) "menu", NULL
37083 };
37084
37085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37087 if (SWIG_arg_fail(1)) SWIG_fail;
37088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37089 if (SWIG_arg_fail(2)) SWIG_fail;
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 (arg1)->SetSubMenu(arg2);
37093
37094 wxPyEndAllowThreads(__tstate);
37095 if (PyErr_Occurred()) SWIG_fail;
37096 }
37097 Py_INCREF(Py_None); resultobj = Py_None;
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj;
37106 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37107 wxMenu *result;
37108 PyObject * obj0 = 0 ;
37109 char *kwnames[] = {
37110 (char *) "self", NULL
37111 };
37112
37113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37115 if (SWIG_arg_fail(1)) SWIG_fail;
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37119
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 {
37124 resultobj = wxPyMake_wxObject(result, 0);
37125 }
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj;
37134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37135 bool arg2 = (bool) true ;
37136 PyObject * obj0 = 0 ;
37137 PyObject * obj1 = 0 ;
37138 char *kwnames[] = {
37139 (char *) "self",(char *) "enable", NULL
37140 };
37141
37142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37144 if (SWIG_arg_fail(1)) SWIG_fail;
37145 if (obj1) {
37146 {
37147 arg2 = (bool)(SWIG_As_bool(obj1));
37148 if (SWIG_arg_fail(2)) SWIG_fail;
37149 }
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 (arg1)->Enable(arg2);
37154
37155 wxPyEndAllowThreads(__tstate);
37156 if (PyErr_Occurred()) SWIG_fail;
37157 }
37158 Py_INCREF(Py_None); resultobj = Py_None;
37159 return resultobj;
37160 fail:
37161 return NULL;
37162 }
37163
37164
37165 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37166 PyObject *resultobj;
37167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37168 bool result;
37169 PyObject * obj0 = 0 ;
37170 char *kwnames[] = {
37171 (char *) "self", NULL
37172 };
37173
37174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37176 if (SWIG_arg_fail(1)) SWIG_fail;
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37180
37181 wxPyEndAllowThreads(__tstate);
37182 if (PyErr_Occurred()) SWIG_fail;
37183 }
37184 {
37185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37186 }
37187 return resultobj;
37188 fail:
37189 return NULL;
37190 }
37191
37192
37193 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37194 PyObject *resultobj;
37195 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37196 bool arg2 = (bool) true ;
37197 PyObject * obj0 = 0 ;
37198 PyObject * obj1 = 0 ;
37199 char *kwnames[] = {
37200 (char *) "self",(char *) "check", NULL
37201 };
37202
37203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37205 if (SWIG_arg_fail(1)) SWIG_fail;
37206 if (obj1) {
37207 {
37208 arg2 = (bool)(SWIG_As_bool(obj1));
37209 if (SWIG_arg_fail(2)) SWIG_fail;
37210 }
37211 }
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 (arg1)->Check(arg2);
37215
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 Py_INCREF(Py_None); resultobj = Py_None;
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37227 PyObject *resultobj;
37228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37229 bool result;
37230 PyObject * obj0 = 0 ;
37231 char *kwnames[] = {
37232 (char *) "self", NULL
37233 };
37234
37235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37237 if (SWIG_arg_fail(1)) SWIG_fail;
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37241
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 {
37246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37247 }
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj;
37256 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37257 PyObject * obj0 = 0 ;
37258 char *kwnames[] = {
37259 (char *) "self", NULL
37260 };
37261
37262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37264 if (SWIG_arg_fail(1)) SWIG_fail;
37265 {
37266 PyThreadState* __tstate = wxPyBeginAllowThreads();
37267 (arg1)->Toggle();
37268
37269 wxPyEndAllowThreads(__tstate);
37270 if (PyErr_Occurred()) SWIG_fail;
37271 }
37272 Py_INCREF(Py_None); resultobj = Py_None;
37273 return resultobj;
37274 fail:
37275 return NULL;
37276 }
37277
37278
37279 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37280 PyObject *resultobj;
37281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37282 wxString *arg2 = 0 ;
37283 bool temp2 = false ;
37284 PyObject * obj0 = 0 ;
37285 PyObject * obj1 = 0 ;
37286 char *kwnames[] = {
37287 (char *) "self",(char *) "str", NULL
37288 };
37289
37290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37292 if (SWIG_arg_fail(1)) SWIG_fail;
37293 {
37294 arg2 = wxString_in_helper(obj1);
37295 if (arg2 == NULL) SWIG_fail;
37296 temp2 = true;
37297 }
37298 {
37299 PyThreadState* __tstate = wxPyBeginAllowThreads();
37300 (arg1)->SetHelp((wxString const &)*arg2);
37301
37302 wxPyEndAllowThreads(__tstate);
37303 if (PyErr_Occurred()) SWIG_fail;
37304 }
37305 Py_INCREF(Py_None); resultobj = Py_None;
37306 {
37307 if (temp2)
37308 delete arg2;
37309 }
37310 return resultobj;
37311 fail:
37312 {
37313 if (temp2)
37314 delete arg2;
37315 }
37316 return NULL;
37317 }
37318
37319
37320 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37321 PyObject *resultobj;
37322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37323 wxString *result;
37324 PyObject * obj0 = 0 ;
37325 char *kwnames[] = {
37326 (char *) "self", NULL
37327 };
37328
37329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37331 if (SWIG_arg_fail(1)) SWIG_fail;
37332 {
37333 PyThreadState* __tstate = wxPyBeginAllowThreads();
37334 {
37335 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37336 result = (wxString *) &_result_ref;
37337 }
37338
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 {
37343 #if wxUSE_UNICODE
37344 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37345 #else
37346 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37347 #endif
37348 }
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37356 PyObject *resultobj;
37357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37358 wxAcceleratorEntry *result;
37359 PyObject * obj0 = 0 ;
37360 char *kwnames[] = {
37361 (char *) "self", NULL
37362 };
37363
37364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37366 if (SWIG_arg_fail(1)) SWIG_fail;
37367 {
37368 PyThreadState* __tstate = wxPyBeginAllowThreads();
37369 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37370
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37375 return resultobj;
37376 fail:
37377 return NULL;
37378 }
37379
37380
37381 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37382 PyObject *resultobj;
37383 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37384 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37385 PyObject * obj0 = 0 ;
37386 PyObject * obj1 = 0 ;
37387 char *kwnames[] = {
37388 (char *) "self",(char *) "accel", NULL
37389 };
37390
37391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37393 if (SWIG_arg_fail(1)) SWIG_fail;
37394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37395 if (SWIG_arg_fail(2)) SWIG_fail;
37396 {
37397 PyThreadState* __tstate = wxPyBeginAllowThreads();
37398 (arg1)->SetAccel(arg2);
37399
37400 wxPyEndAllowThreads(__tstate);
37401 if (PyErr_Occurred()) SWIG_fail;
37402 }
37403 Py_INCREF(Py_None); resultobj = Py_None;
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37411 PyObject *resultobj;
37412 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37413 wxFont *arg2 = 0 ;
37414 PyObject * obj0 = 0 ;
37415 PyObject * obj1 = 0 ;
37416 char *kwnames[] = {
37417 (char *) "self",(char *) "font", NULL
37418 };
37419
37420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37422 if (SWIG_arg_fail(1)) SWIG_fail;
37423 {
37424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37425 if (SWIG_arg_fail(2)) SWIG_fail;
37426 if (arg2 == NULL) {
37427 SWIG_null_ref("wxFont");
37428 }
37429 if (SWIG_arg_fail(2)) SWIG_fail;
37430 }
37431 {
37432 PyThreadState* __tstate = wxPyBeginAllowThreads();
37433 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37434
37435 wxPyEndAllowThreads(__tstate);
37436 if (PyErr_Occurred()) SWIG_fail;
37437 }
37438 Py_INCREF(Py_None); resultobj = Py_None;
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37446 PyObject *resultobj;
37447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37448 wxFont result;
37449 PyObject * obj0 = 0 ;
37450 char *kwnames[] = {
37451 (char *) "self", NULL
37452 };
37453
37454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37456 if (SWIG_arg_fail(1)) SWIG_fail;
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 result = wxMenuItem_GetFont(arg1);
37460
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 wxFont * resultptr;
37466 resultptr = new wxFont((wxFont &)(result));
37467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37468 }
37469 return resultobj;
37470 fail:
37471 return NULL;
37472 }
37473
37474
37475 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37476 PyObject *resultobj;
37477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37478 wxColour *arg2 = 0 ;
37479 wxColour temp2 ;
37480 PyObject * obj0 = 0 ;
37481 PyObject * obj1 = 0 ;
37482 char *kwnames[] = {
37483 (char *) "self",(char *) "colText", NULL
37484 };
37485
37486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37488 if (SWIG_arg_fail(1)) SWIG_fail;
37489 {
37490 arg2 = &temp2;
37491 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37492 }
37493 {
37494 PyThreadState* __tstate = wxPyBeginAllowThreads();
37495 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37496
37497 wxPyEndAllowThreads(__tstate);
37498 if (PyErr_Occurred()) SWIG_fail;
37499 }
37500 Py_INCREF(Py_None); resultobj = Py_None;
37501 return resultobj;
37502 fail:
37503 return NULL;
37504 }
37505
37506
37507 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37508 PyObject *resultobj;
37509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37510 wxColour result;
37511 PyObject * obj0 = 0 ;
37512 char *kwnames[] = {
37513 (char *) "self", NULL
37514 };
37515
37516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37518 if (SWIG_arg_fail(1)) SWIG_fail;
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 result = wxMenuItem_GetTextColour(arg1);
37522
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 {
37527 wxColour * resultptr;
37528 resultptr = new wxColour((wxColour &)(result));
37529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37530 }
37531 return resultobj;
37532 fail:
37533 return NULL;
37534 }
37535
37536
37537 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37538 PyObject *resultobj;
37539 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37540 wxColour *arg2 = 0 ;
37541 wxColour temp2 ;
37542 PyObject * obj0 = 0 ;
37543 PyObject * obj1 = 0 ;
37544 char *kwnames[] = {
37545 (char *) "self",(char *) "colBack", NULL
37546 };
37547
37548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37550 if (SWIG_arg_fail(1)) SWIG_fail;
37551 {
37552 arg2 = &temp2;
37553 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37554 }
37555 {
37556 PyThreadState* __tstate = wxPyBeginAllowThreads();
37557 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37558
37559 wxPyEndAllowThreads(__tstate);
37560 if (PyErr_Occurred()) SWIG_fail;
37561 }
37562 Py_INCREF(Py_None); resultobj = Py_None;
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37570 PyObject *resultobj;
37571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37572 wxColour result;
37573 PyObject * obj0 = 0 ;
37574 char *kwnames[] = {
37575 (char *) "self", NULL
37576 };
37577
37578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37580 if (SWIG_arg_fail(1)) SWIG_fail;
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 result = wxMenuItem_GetBackgroundColour(arg1);
37584
37585 wxPyEndAllowThreads(__tstate);
37586 if (PyErr_Occurred()) SWIG_fail;
37587 }
37588 {
37589 wxColour * resultptr;
37590 resultptr = new wxColour((wxColour &)(result));
37591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37592 }
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37600 PyObject *resultobj;
37601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37602 wxBitmap *arg2 = 0 ;
37603 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37604 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 PyObject * obj2 = 0 ;
37608 char *kwnames[] = {
37609 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37610 };
37611
37612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37614 if (SWIG_arg_fail(1)) SWIG_fail;
37615 {
37616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37617 if (SWIG_arg_fail(2)) SWIG_fail;
37618 if (arg2 == NULL) {
37619 SWIG_null_ref("wxBitmap");
37620 }
37621 if (SWIG_arg_fail(2)) SWIG_fail;
37622 }
37623 if (obj2) {
37624 {
37625 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37626 if (SWIG_arg_fail(3)) SWIG_fail;
37627 if (arg3 == NULL) {
37628 SWIG_null_ref("wxBitmap");
37629 }
37630 if (SWIG_arg_fail(3)) SWIG_fail;
37631 }
37632 }
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37636
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 Py_INCREF(Py_None); resultobj = Py_None;
37641 return resultobj;
37642 fail:
37643 return NULL;
37644 }
37645
37646
37647 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37648 PyObject *resultobj;
37649 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37650 wxBitmap *arg2 = 0 ;
37651 PyObject * obj0 = 0 ;
37652 PyObject * obj1 = 0 ;
37653 char *kwnames[] = {
37654 (char *) "self",(char *) "bmpDisabled", NULL
37655 };
37656
37657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37659 if (SWIG_arg_fail(1)) SWIG_fail;
37660 {
37661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37662 if (SWIG_arg_fail(2)) SWIG_fail;
37663 if (arg2 == NULL) {
37664 SWIG_null_ref("wxBitmap");
37665 }
37666 if (SWIG_arg_fail(2)) SWIG_fail;
37667 }
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37671
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 Py_INCREF(Py_None); resultobj = Py_None;
37676 return resultobj;
37677 fail:
37678 return NULL;
37679 }
37680
37681
37682 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37683 PyObject *resultobj;
37684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37685 wxBitmap *result;
37686 PyObject * obj0 = 0 ;
37687 char *kwnames[] = {
37688 (char *) "self", NULL
37689 };
37690
37691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37693 if (SWIG_arg_fail(1)) SWIG_fail;
37694 {
37695 PyThreadState* __tstate = wxPyBeginAllowThreads();
37696 {
37697 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37698 result = (wxBitmap *) &_result_ref;
37699 }
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 {
37705 wxBitmap* resultptr = new wxBitmap(*result);
37706 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37707 }
37708 return resultobj;
37709 fail:
37710 return NULL;
37711 }
37712
37713
37714 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37715 PyObject *resultobj;
37716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37717 int arg2 ;
37718 PyObject * obj0 = 0 ;
37719 PyObject * obj1 = 0 ;
37720 char *kwnames[] = {
37721 (char *) "self",(char *) "nWidth", NULL
37722 };
37723
37724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37726 if (SWIG_arg_fail(1)) SWIG_fail;
37727 {
37728 arg2 = (int)(SWIG_As_int(obj1));
37729 if (SWIG_arg_fail(2)) SWIG_fail;
37730 }
37731 {
37732 PyThreadState* __tstate = wxPyBeginAllowThreads();
37733 wxMenuItem_SetMarginWidth(arg1,arg2);
37734
37735 wxPyEndAllowThreads(__tstate);
37736 if (PyErr_Occurred()) SWIG_fail;
37737 }
37738 Py_INCREF(Py_None); resultobj = Py_None;
37739 return resultobj;
37740 fail:
37741 return NULL;
37742 }
37743
37744
37745 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37746 PyObject *resultobj;
37747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37748 int result;
37749 PyObject * obj0 = 0 ;
37750 char *kwnames[] = {
37751 (char *) "self", NULL
37752 };
37753
37754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37756 if (SWIG_arg_fail(1)) SWIG_fail;
37757 {
37758 PyThreadState* __tstate = wxPyBeginAllowThreads();
37759 result = (int)wxMenuItem_GetMarginWidth(arg1);
37760
37761 wxPyEndAllowThreads(__tstate);
37762 if (PyErr_Occurred()) SWIG_fail;
37763 }
37764 {
37765 resultobj = SWIG_From_int((int)(result));
37766 }
37767 return resultobj;
37768 fail:
37769 return NULL;
37770 }
37771
37772
37773 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37774 PyObject *resultobj;
37775 int result;
37776 char *kwnames[] = {
37777 NULL
37778 };
37779
37780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 result = (int)MenuItem_GetDefaultMarginWidth();
37784
37785 wxPyEndAllowThreads(__tstate);
37786 if (PyErr_Occurred()) SWIG_fail;
37787 }
37788 {
37789 resultobj = SWIG_From_int((int)(result));
37790 }
37791 return resultobj;
37792 fail:
37793 return NULL;
37794 }
37795
37796
37797 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37798 PyObject *resultobj;
37799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37800 bool result;
37801 PyObject * obj0 = 0 ;
37802 char *kwnames[] = {
37803 (char *) "self", NULL
37804 };
37805
37806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37808 if (SWIG_arg_fail(1)) SWIG_fail;
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37812
37813 wxPyEndAllowThreads(__tstate);
37814 if (PyErr_Occurred()) SWIG_fail;
37815 }
37816 {
37817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37818 }
37819 return resultobj;
37820 fail:
37821 return NULL;
37822 }
37823
37824
37825 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37826 PyObject *resultobj;
37827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37828 bool arg2 = (bool) true ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char *kwnames[] = {
37832 (char *) "self",(char *) "ownerDrawn", NULL
37833 };
37834
37835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37837 if (SWIG_arg_fail(1)) SWIG_fail;
37838 if (obj1) {
37839 {
37840 arg2 = (bool)(SWIG_As_bool(obj1));
37841 if (SWIG_arg_fail(2)) SWIG_fail;
37842 }
37843 }
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37847
37848 wxPyEndAllowThreads(__tstate);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 }
37851 Py_INCREF(Py_None); resultobj = Py_None;
37852 return resultobj;
37853 fail:
37854 return NULL;
37855 }
37856
37857
37858 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37859 PyObject *resultobj;
37860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37861 PyObject * obj0 = 0 ;
37862 char *kwnames[] = {
37863 (char *) "self", NULL
37864 };
37865
37866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37868 if (SWIG_arg_fail(1)) SWIG_fail;
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 wxMenuItem_ResetOwnerDrawn(arg1);
37872
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 Py_INCREF(Py_None); resultobj = Py_None;
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj;
37885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37886 wxBitmap *arg2 = 0 ;
37887 PyObject * obj0 = 0 ;
37888 PyObject * obj1 = 0 ;
37889 char *kwnames[] = {
37890 (char *) "self",(char *) "bitmap", NULL
37891 };
37892
37893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37895 if (SWIG_arg_fail(1)) SWIG_fail;
37896 {
37897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37898 if (SWIG_arg_fail(2)) SWIG_fail;
37899 if (arg2 == NULL) {
37900 SWIG_null_ref("wxBitmap");
37901 }
37902 if (SWIG_arg_fail(2)) SWIG_fail;
37903 }
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37907
37908 wxPyEndAllowThreads(__tstate);
37909 if (PyErr_Occurred()) SWIG_fail;
37910 }
37911 Py_INCREF(Py_None); resultobj = Py_None;
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj;
37920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37921 wxBitmap *result;
37922 PyObject * obj0 = 0 ;
37923 char *kwnames[] = {
37924 (char *) "self", NULL
37925 };
37926
37927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37929 if (SWIG_arg_fail(1)) SWIG_fail;
37930 {
37931 PyThreadState* __tstate = wxPyBeginAllowThreads();
37932 {
37933 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37934 result = (wxBitmap *) &_result_ref;
37935 }
37936
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 {
37941 wxBitmap* resultptr = new wxBitmap(*result);
37942 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37943 }
37944 return resultobj;
37945 fail:
37946 return NULL;
37947 }
37948
37949
37950 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37951 PyObject *obj;
37952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37953 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37954 Py_INCREF(obj);
37955 return Py_BuildValue((char *)"");
37956 }
37957 static int _wrap_ControlNameStr_set(PyObject *) {
37958 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37959 return 1;
37960 }
37961
37962
37963 static PyObject *_wrap_ControlNameStr_get(void) {
37964 PyObject *pyobj;
37965
37966 {
37967 #if wxUSE_UNICODE
37968 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37969 #else
37970 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37971 #endif
37972 }
37973 return pyobj;
37974 }
37975
37976
37977 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37978 PyObject *resultobj;
37979 wxWindow *arg1 = (wxWindow *) 0 ;
37980 int arg2 = (int) -1 ;
37981 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37982 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37983 wxSize const &arg4_defvalue = wxDefaultSize ;
37984 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37985 long arg5 = (long) 0 ;
37986 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37987 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37988 wxString const &arg7_defvalue = wxPyControlNameStr ;
37989 wxString *arg7 = (wxString *) &arg7_defvalue ;
37990 wxControl *result;
37991 wxPoint temp3 ;
37992 wxSize temp4 ;
37993 bool temp7 = false ;
37994 PyObject * obj0 = 0 ;
37995 PyObject * obj1 = 0 ;
37996 PyObject * obj2 = 0 ;
37997 PyObject * obj3 = 0 ;
37998 PyObject * obj4 = 0 ;
37999 PyObject * obj5 = 0 ;
38000 PyObject * obj6 = 0 ;
38001 char *kwnames[] = {
38002 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38003 };
38004
38005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38007 if (SWIG_arg_fail(1)) SWIG_fail;
38008 if (obj1) {
38009 {
38010 arg2 = (int)(SWIG_As_int(obj1));
38011 if (SWIG_arg_fail(2)) SWIG_fail;
38012 }
38013 }
38014 if (obj2) {
38015 {
38016 arg3 = &temp3;
38017 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38018 }
38019 }
38020 if (obj3) {
38021 {
38022 arg4 = &temp4;
38023 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38024 }
38025 }
38026 if (obj4) {
38027 {
38028 arg5 = (long)(SWIG_As_long(obj4));
38029 if (SWIG_arg_fail(5)) SWIG_fail;
38030 }
38031 }
38032 if (obj5) {
38033 {
38034 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38035 if (SWIG_arg_fail(6)) SWIG_fail;
38036 if (arg6 == NULL) {
38037 SWIG_null_ref("wxValidator");
38038 }
38039 if (SWIG_arg_fail(6)) SWIG_fail;
38040 }
38041 }
38042 if (obj6) {
38043 {
38044 arg7 = wxString_in_helper(obj6);
38045 if (arg7 == NULL) SWIG_fail;
38046 temp7 = true;
38047 }
38048 }
38049 {
38050 if (!wxPyCheckForApp()) SWIG_fail;
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38053
38054 wxPyEndAllowThreads(__tstate);
38055 if (PyErr_Occurred()) SWIG_fail;
38056 }
38057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38058 {
38059 if (temp7)
38060 delete arg7;
38061 }
38062 return resultobj;
38063 fail:
38064 {
38065 if (temp7)
38066 delete arg7;
38067 }
38068 return NULL;
38069 }
38070
38071
38072 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj;
38074 wxControl *result;
38075 char *kwnames[] = {
38076 NULL
38077 };
38078
38079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38080 {
38081 if (!wxPyCheckForApp()) SWIG_fail;
38082 PyThreadState* __tstate = wxPyBeginAllowThreads();
38083 result = (wxControl *)new wxControl();
38084
38085 wxPyEndAllowThreads(__tstate);
38086 if (PyErr_Occurred()) SWIG_fail;
38087 }
38088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38089 return resultobj;
38090 fail:
38091 return NULL;
38092 }
38093
38094
38095 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38096 PyObject *resultobj;
38097 wxControl *arg1 = (wxControl *) 0 ;
38098 wxWindow *arg2 = (wxWindow *) 0 ;
38099 int arg3 = (int) -1 ;
38100 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38101 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38102 wxSize const &arg5_defvalue = wxDefaultSize ;
38103 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38104 long arg6 = (long) 0 ;
38105 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38106 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38107 wxString const &arg8_defvalue = wxPyControlNameStr ;
38108 wxString *arg8 = (wxString *) &arg8_defvalue ;
38109 bool result;
38110 wxPoint temp4 ;
38111 wxSize temp5 ;
38112 bool temp8 = false ;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 PyObject * obj2 = 0 ;
38116 PyObject * obj3 = 0 ;
38117 PyObject * obj4 = 0 ;
38118 PyObject * obj5 = 0 ;
38119 PyObject * obj6 = 0 ;
38120 PyObject * obj7 = 0 ;
38121 char *kwnames[] = {
38122 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38123 };
38124
38125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38127 if (SWIG_arg_fail(1)) SWIG_fail;
38128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38129 if (SWIG_arg_fail(2)) SWIG_fail;
38130 if (obj2) {
38131 {
38132 arg3 = (int)(SWIG_As_int(obj2));
38133 if (SWIG_arg_fail(3)) SWIG_fail;
38134 }
38135 }
38136 if (obj3) {
38137 {
38138 arg4 = &temp4;
38139 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38140 }
38141 }
38142 if (obj4) {
38143 {
38144 arg5 = &temp5;
38145 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38146 }
38147 }
38148 if (obj5) {
38149 {
38150 arg6 = (long)(SWIG_As_long(obj5));
38151 if (SWIG_arg_fail(6)) SWIG_fail;
38152 }
38153 }
38154 if (obj6) {
38155 {
38156 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38157 if (SWIG_arg_fail(7)) SWIG_fail;
38158 if (arg7 == NULL) {
38159 SWIG_null_ref("wxValidator");
38160 }
38161 if (SWIG_arg_fail(7)) SWIG_fail;
38162 }
38163 }
38164 if (obj7) {
38165 {
38166 arg8 = wxString_in_helper(obj7);
38167 if (arg8 == NULL) SWIG_fail;
38168 temp8 = true;
38169 }
38170 }
38171 {
38172 PyThreadState* __tstate = wxPyBeginAllowThreads();
38173 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38174
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 {
38179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38180 }
38181 {
38182 if (temp8)
38183 delete arg8;
38184 }
38185 return resultobj;
38186 fail:
38187 {
38188 if (temp8)
38189 delete arg8;
38190 }
38191 return NULL;
38192 }
38193
38194
38195 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38196 PyObject *resultobj;
38197 wxControl *arg1 = (wxControl *) 0 ;
38198 wxCommandEvent *arg2 = 0 ;
38199 PyObject * obj0 = 0 ;
38200 PyObject * obj1 = 0 ;
38201 char *kwnames[] = {
38202 (char *) "self",(char *) "event", NULL
38203 };
38204
38205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38207 if (SWIG_arg_fail(1)) SWIG_fail;
38208 {
38209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38210 if (SWIG_arg_fail(2)) SWIG_fail;
38211 if (arg2 == NULL) {
38212 SWIG_null_ref("wxCommandEvent");
38213 }
38214 if (SWIG_arg_fail(2)) SWIG_fail;
38215 }
38216 {
38217 PyThreadState* __tstate = wxPyBeginAllowThreads();
38218 (arg1)->Command(*arg2);
38219
38220 wxPyEndAllowThreads(__tstate);
38221 if (PyErr_Occurred()) SWIG_fail;
38222 }
38223 Py_INCREF(Py_None); resultobj = Py_None;
38224 return resultobj;
38225 fail:
38226 return NULL;
38227 }
38228
38229
38230 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38231 PyObject *resultobj;
38232 wxControl *arg1 = (wxControl *) 0 ;
38233 wxString result;
38234 PyObject * obj0 = 0 ;
38235 char *kwnames[] = {
38236 (char *) "self", NULL
38237 };
38238
38239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38241 if (SWIG_arg_fail(1)) SWIG_fail;
38242 {
38243 PyThreadState* __tstate = wxPyBeginAllowThreads();
38244 result = (arg1)->GetLabel();
38245
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 #if wxUSE_UNICODE
38251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38252 #else
38253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38254 #endif
38255 }
38256 return resultobj;
38257 fail:
38258 return NULL;
38259 }
38260
38261
38262 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38263 PyObject *resultobj;
38264 wxControl *arg1 = (wxControl *) 0 ;
38265 wxString *arg2 = 0 ;
38266 bool temp2 = false ;
38267 PyObject * obj0 = 0 ;
38268 PyObject * obj1 = 0 ;
38269 char *kwnames[] = {
38270 (char *) "self",(char *) "label", NULL
38271 };
38272
38273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38275 if (SWIG_arg_fail(1)) SWIG_fail;
38276 {
38277 arg2 = wxString_in_helper(obj1);
38278 if (arg2 == NULL) SWIG_fail;
38279 temp2 = true;
38280 }
38281 {
38282 PyThreadState* __tstate = wxPyBeginAllowThreads();
38283 (arg1)->SetLabel((wxString const &)*arg2);
38284
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 Py_INCREF(Py_None); resultobj = Py_None;
38289 {
38290 if (temp2)
38291 delete arg2;
38292 }
38293 return resultobj;
38294 fail:
38295 {
38296 if (temp2)
38297 delete arg2;
38298 }
38299 return NULL;
38300 }
38301
38302
38303 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj;
38305 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38306 wxVisualAttributes result;
38307 PyObject * obj0 = 0 ;
38308 char *kwnames[] = {
38309 (char *) "variant", NULL
38310 };
38311
38312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38313 if (obj0) {
38314 {
38315 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
38316 if (SWIG_arg_fail(1)) SWIG_fail;
38317 }
38318 }
38319 {
38320 if (!wxPyCheckForApp()) SWIG_fail;
38321 PyThreadState* __tstate = wxPyBeginAllowThreads();
38322 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
38323
38324 wxPyEndAllowThreads(__tstate);
38325 if (PyErr_Occurred()) SWIG_fail;
38326 }
38327 {
38328 wxVisualAttributes * resultptr;
38329 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
38330 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38331 }
38332 return resultobj;
38333 fail:
38334 return NULL;
38335 }
38336
38337
38338 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38339 PyObject *obj;
38340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38341 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38342 Py_INCREF(obj);
38343 return Py_BuildValue((char *)"");
38344 }
38345 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj;
38347 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38348 wxString *arg2 = 0 ;
38349 PyObject *arg3 = (PyObject *) NULL ;
38350 int result;
38351 bool temp2 = false ;
38352 PyObject * obj0 = 0 ;
38353 PyObject * obj1 = 0 ;
38354 PyObject * obj2 = 0 ;
38355 char *kwnames[] = {
38356 (char *) "self",(char *) "item",(char *) "clientData", NULL
38357 };
38358
38359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38361 if (SWIG_arg_fail(1)) SWIG_fail;
38362 {
38363 arg2 = wxString_in_helper(obj1);
38364 if (arg2 == NULL) SWIG_fail;
38365 temp2 = true;
38366 }
38367 if (obj2) {
38368 arg3 = obj2;
38369 }
38370 {
38371 PyThreadState* __tstate = wxPyBeginAllowThreads();
38372 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38373
38374 wxPyEndAllowThreads(__tstate);
38375 if (PyErr_Occurred()) SWIG_fail;
38376 }
38377 {
38378 resultobj = SWIG_From_int((int)(result));
38379 }
38380 {
38381 if (temp2)
38382 delete arg2;
38383 }
38384 return resultobj;
38385 fail:
38386 {
38387 if (temp2)
38388 delete arg2;
38389 }
38390 return NULL;
38391 }
38392
38393
38394 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj;
38396 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38397 wxArrayString *arg2 = 0 ;
38398 bool temp2 = false ;
38399 PyObject * obj0 = 0 ;
38400 PyObject * obj1 = 0 ;
38401 char *kwnames[] = {
38402 (char *) "self",(char *) "strings", NULL
38403 };
38404
38405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38407 if (SWIG_arg_fail(1)) SWIG_fail;
38408 {
38409 if (! PySequence_Check(obj1)) {
38410 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38411 SWIG_fail;
38412 }
38413 arg2 = new wxArrayString;
38414 temp2 = true;
38415 int i, len=PySequence_Length(obj1);
38416 for (i=0; i<len; i++) {
38417 PyObject* item = PySequence_GetItem(obj1, i);
38418 wxString* s = wxString_in_helper(item);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 arg2->Add(*s);
38421 delete s;
38422 Py_DECREF(item);
38423 }
38424 }
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 (arg1)->Append((wxArrayString const &)*arg2);
38428
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 Py_INCREF(Py_None); resultobj = Py_None;
38433 {
38434 if (temp2) delete arg2;
38435 }
38436 return resultobj;
38437 fail:
38438 {
38439 if (temp2) delete arg2;
38440 }
38441 return NULL;
38442 }
38443
38444
38445 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38446 PyObject *resultobj;
38447 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38448 wxString *arg2 = 0 ;
38449 int arg3 ;
38450 PyObject *arg4 = (PyObject *) NULL ;
38451 int result;
38452 bool temp2 = false ;
38453 PyObject * obj0 = 0 ;
38454 PyObject * obj1 = 0 ;
38455 PyObject * obj2 = 0 ;
38456 PyObject * obj3 = 0 ;
38457 char *kwnames[] = {
38458 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38459 };
38460
38461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38463 if (SWIG_arg_fail(1)) SWIG_fail;
38464 {
38465 arg2 = wxString_in_helper(obj1);
38466 if (arg2 == NULL) SWIG_fail;
38467 temp2 = true;
38468 }
38469 {
38470 arg3 = (int)(SWIG_As_int(obj2));
38471 if (SWIG_arg_fail(3)) SWIG_fail;
38472 }
38473 if (obj3) {
38474 arg4 = obj3;
38475 }
38476 {
38477 PyThreadState* __tstate = wxPyBeginAllowThreads();
38478 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38479
38480 wxPyEndAllowThreads(__tstate);
38481 if (PyErr_Occurred()) SWIG_fail;
38482 }
38483 {
38484 resultobj = SWIG_From_int((int)(result));
38485 }
38486 {
38487 if (temp2)
38488 delete arg2;
38489 }
38490 return resultobj;
38491 fail:
38492 {
38493 if (temp2)
38494 delete arg2;
38495 }
38496 return NULL;
38497 }
38498
38499
38500 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38501 PyObject *resultobj;
38502 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38503 PyObject * obj0 = 0 ;
38504 char *kwnames[] = {
38505 (char *) "self", NULL
38506 };
38507
38508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38510 if (SWIG_arg_fail(1)) SWIG_fail;
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 (arg1)->Clear();
38514
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 Py_INCREF(Py_None); resultobj = Py_None;
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj;
38527 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38528 int arg2 ;
38529 PyObject * obj0 = 0 ;
38530 PyObject * obj1 = 0 ;
38531 char *kwnames[] = {
38532 (char *) "self",(char *) "n", NULL
38533 };
38534
38535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38537 if (SWIG_arg_fail(1)) SWIG_fail;
38538 {
38539 arg2 = (int)(SWIG_As_int(obj1));
38540 if (SWIG_arg_fail(2)) SWIG_fail;
38541 }
38542 {
38543 PyThreadState* __tstate = wxPyBeginAllowThreads();
38544 (arg1)->Delete(arg2);
38545
38546 wxPyEndAllowThreads(__tstate);
38547 if (PyErr_Occurred()) SWIG_fail;
38548 }
38549 Py_INCREF(Py_None); resultobj = Py_None;
38550 return resultobj;
38551 fail:
38552 return NULL;
38553 }
38554
38555
38556 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38557 PyObject *resultobj;
38558 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38559 int arg2 ;
38560 PyObject *result;
38561 PyObject * obj0 = 0 ;
38562 PyObject * obj1 = 0 ;
38563 char *kwnames[] = {
38564 (char *) "self",(char *) "n", NULL
38565 };
38566
38567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
38576 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38577
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 resultobj = result;
38582 return resultobj;
38583 fail:
38584 return NULL;
38585 }
38586
38587
38588 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38589 PyObject *resultobj;
38590 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38591 int arg2 ;
38592 PyObject *arg3 = (PyObject *) 0 ;
38593 PyObject * obj0 = 0 ;
38594 PyObject * obj1 = 0 ;
38595 PyObject * obj2 = 0 ;
38596 char *kwnames[] = {
38597 (char *) "self",(char *) "n",(char *) "clientData", NULL
38598 };
38599
38600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38602 if (SWIG_arg_fail(1)) SWIG_fail;
38603 {
38604 arg2 = (int)(SWIG_As_int(obj1));
38605 if (SWIG_arg_fail(2)) SWIG_fail;
38606 }
38607 arg3 = obj2;
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 wxItemContainer_SetClientData(arg1,arg2,arg3);
38611
38612 wxPyEndAllowThreads(__tstate);
38613 if (PyErr_Occurred()) SWIG_fail;
38614 }
38615 Py_INCREF(Py_None); resultobj = Py_None;
38616 return resultobj;
38617 fail:
38618 return NULL;
38619 }
38620
38621
38622 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38623 PyObject *resultobj;
38624 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38625 int result;
38626 PyObject * obj0 = 0 ;
38627 char *kwnames[] = {
38628 (char *) "self", NULL
38629 };
38630
38631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38633 if (SWIG_arg_fail(1)) SWIG_fail;
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 result = (int)((wxItemContainer const *)arg1)->GetCount();
38637
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 {
38642 resultobj = SWIG_From_int((int)(result));
38643 }
38644 return resultobj;
38645 fail:
38646 return NULL;
38647 }
38648
38649
38650 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38651 PyObject *resultobj;
38652 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38653 bool result;
38654 PyObject * obj0 = 0 ;
38655 char *kwnames[] = {
38656 (char *) "self", NULL
38657 };
38658
38659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38661 if (SWIG_arg_fail(1)) SWIG_fail;
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38665
38666 wxPyEndAllowThreads(__tstate);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 }
38669 {
38670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38671 }
38672 return resultobj;
38673 fail:
38674 return NULL;
38675 }
38676
38677
38678 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38679 PyObject *resultobj;
38680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38681 int arg2 ;
38682 wxString result;
38683 PyObject * obj0 = 0 ;
38684 PyObject * obj1 = 0 ;
38685 char *kwnames[] = {
38686 (char *) "self",(char *) "n", NULL
38687 };
38688
38689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38691 if (SWIG_arg_fail(1)) SWIG_fail;
38692 {
38693 arg2 = (int)(SWIG_As_int(obj1));
38694 if (SWIG_arg_fail(2)) SWIG_fail;
38695 }
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38699
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 {
38704 #if wxUSE_UNICODE
38705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38706 #else
38707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38708 #endif
38709 }
38710 return resultobj;
38711 fail:
38712 return NULL;
38713 }
38714
38715
38716 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38717 PyObject *resultobj;
38718 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38719 wxArrayString result;
38720 PyObject * obj0 = 0 ;
38721 char *kwnames[] = {
38722 (char *) "self", NULL
38723 };
38724
38725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38727 if (SWIG_arg_fail(1)) SWIG_fail;
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = ((wxItemContainer const *)arg1)->GetStrings();
38731
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxArrayString2PyList_helper(result);
38737 }
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj;
38746 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38747 int arg2 ;
38748 wxString *arg3 = 0 ;
38749 bool temp3 = false ;
38750 PyObject * obj0 = 0 ;
38751 PyObject * obj1 = 0 ;
38752 PyObject * obj2 = 0 ;
38753 char *kwnames[] = {
38754 (char *) "self",(char *) "n",(char *) "s", NULL
38755 };
38756
38757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38759 if (SWIG_arg_fail(1)) SWIG_fail;
38760 {
38761 arg2 = (int)(SWIG_As_int(obj1));
38762 if (SWIG_arg_fail(2)) SWIG_fail;
38763 }
38764 {
38765 arg3 = wxString_in_helper(obj2);
38766 if (arg3 == NULL) SWIG_fail;
38767 temp3 = true;
38768 }
38769 {
38770 PyThreadState* __tstate = wxPyBeginAllowThreads();
38771 (arg1)->SetString(arg2,(wxString const &)*arg3);
38772
38773 wxPyEndAllowThreads(__tstate);
38774 if (PyErr_Occurred()) SWIG_fail;
38775 }
38776 Py_INCREF(Py_None); resultobj = Py_None;
38777 {
38778 if (temp3)
38779 delete arg3;
38780 }
38781 return resultobj;
38782 fail:
38783 {
38784 if (temp3)
38785 delete arg3;
38786 }
38787 return NULL;
38788 }
38789
38790
38791 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38792 PyObject *resultobj;
38793 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38794 wxString *arg2 = 0 ;
38795 int result;
38796 bool temp2 = false ;
38797 PyObject * obj0 = 0 ;
38798 PyObject * obj1 = 0 ;
38799 char *kwnames[] = {
38800 (char *) "self",(char *) "s", NULL
38801 };
38802
38803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38805 if (SWIG_arg_fail(1)) SWIG_fail;
38806 {
38807 arg2 = wxString_in_helper(obj1);
38808 if (arg2 == NULL) SWIG_fail;
38809 temp2 = true;
38810 }
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38814
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 {
38819 resultobj = SWIG_From_int((int)(result));
38820 }
38821 {
38822 if (temp2)
38823 delete arg2;
38824 }
38825 return resultobj;
38826 fail:
38827 {
38828 if (temp2)
38829 delete arg2;
38830 }
38831 return NULL;
38832 }
38833
38834
38835 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38836 PyObject *resultobj;
38837 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38838 int arg2 ;
38839 PyObject * obj0 = 0 ;
38840 PyObject * obj1 = 0 ;
38841 char *kwnames[] = {
38842 (char *) "self",(char *) "n", NULL
38843 };
38844
38845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38847 if (SWIG_arg_fail(1)) SWIG_fail;
38848 {
38849 arg2 = (int)(SWIG_As_int(obj1));
38850 if (SWIG_arg_fail(2)) SWIG_fail;
38851 }
38852 {
38853 PyThreadState* __tstate = wxPyBeginAllowThreads();
38854 (arg1)->SetSelection(arg2);
38855
38856 wxPyEndAllowThreads(__tstate);
38857 if (PyErr_Occurred()) SWIG_fail;
38858 }
38859 Py_INCREF(Py_None); resultobj = Py_None;
38860 return resultobj;
38861 fail:
38862 return NULL;
38863 }
38864
38865
38866 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38867 PyObject *resultobj;
38868 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38869 int result;
38870 PyObject * obj0 = 0 ;
38871 char *kwnames[] = {
38872 (char *) "self", NULL
38873 };
38874
38875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38877 if (SWIG_arg_fail(1)) SWIG_fail;
38878 {
38879 PyThreadState* __tstate = wxPyBeginAllowThreads();
38880 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38881
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 {
38886 resultobj = SWIG_From_int((int)(result));
38887 }
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38895 PyObject *resultobj;
38896 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38897 wxString *arg2 = 0 ;
38898 bool result;
38899 bool temp2 = false ;
38900 PyObject * obj0 = 0 ;
38901 PyObject * obj1 = 0 ;
38902 char *kwnames[] = {
38903 (char *) "self",(char *) "s", NULL
38904 };
38905
38906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38908 if (SWIG_arg_fail(1)) SWIG_fail;
38909 {
38910 arg2 = wxString_in_helper(obj1);
38911 if (arg2 == NULL) SWIG_fail;
38912 temp2 = true;
38913 }
38914 {
38915 PyThreadState* __tstate = wxPyBeginAllowThreads();
38916 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38917
38918 wxPyEndAllowThreads(__tstate);
38919 if (PyErr_Occurred()) SWIG_fail;
38920 }
38921 {
38922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38923 }
38924 {
38925 if (temp2)
38926 delete arg2;
38927 }
38928 return resultobj;
38929 fail:
38930 {
38931 if (temp2)
38932 delete arg2;
38933 }
38934 return NULL;
38935 }
38936
38937
38938 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj;
38940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38941 wxString result;
38942 PyObject * obj0 = 0 ;
38943 char *kwnames[] = {
38944 (char *) "self", NULL
38945 };
38946
38947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38949 if (SWIG_arg_fail(1)) SWIG_fail;
38950 {
38951 PyThreadState* __tstate = wxPyBeginAllowThreads();
38952 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38953
38954 wxPyEndAllowThreads(__tstate);
38955 if (PyErr_Occurred()) SWIG_fail;
38956 }
38957 {
38958 #if wxUSE_UNICODE
38959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38960 #else
38961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38962 #endif
38963 }
38964 return resultobj;
38965 fail:
38966 return NULL;
38967 }
38968
38969
38970 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38971 PyObject *resultobj;
38972 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38973 int arg2 ;
38974 PyObject * obj0 = 0 ;
38975 PyObject * obj1 = 0 ;
38976 char *kwnames[] = {
38977 (char *) "self",(char *) "n", NULL
38978 };
38979
38980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38982 if (SWIG_arg_fail(1)) SWIG_fail;
38983 {
38984 arg2 = (int)(SWIG_As_int(obj1));
38985 if (SWIG_arg_fail(2)) SWIG_fail;
38986 }
38987 {
38988 PyThreadState* __tstate = wxPyBeginAllowThreads();
38989 (arg1)->Select(arg2);
38990
38991 wxPyEndAllowThreads(__tstate);
38992 if (PyErr_Occurred()) SWIG_fail;
38993 }
38994 Py_INCREF(Py_None); resultobj = Py_None;
38995 return resultobj;
38996 fail:
38997 return NULL;
38998 }
38999
39000
39001 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39002 PyObject *obj;
39003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39004 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39005 Py_INCREF(obj);
39006 return Py_BuildValue((char *)"");
39007 }
39008 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39009 PyObject *obj;
39010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39011 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39012 Py_INCREF(obj);
39013 return Py_BuildValue((char *)"");
39014 }
39015 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39016 PyObject *resultobj;
39017 wxSizerItem *result;
39018 char *kwnames[] = {
39019 NULL
39020 };
39021
39022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39023 {
39024 PyThreadState* __tstate = wxPyBeginAllowThreads();
39025 result = (wxSizerItem *)new wxSizerItem();
39026
39027 wxPyEndAllowThreads(__tstate);
39028 if (PyErr_Occurred()) SWIG_fail;
39029 }
39030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39031 return resultobj;
39032 fail:
39033 return NULL;
39034 }
39035
39036
39037 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39038 PyObject *resultobj;
39039 wxWindow *arg1 = (wxWindow *) 0 ;
39040 int arg2 ;
39041 int arg3 ;
39042 int arg4 ;
39043 PyObject *arg5 = (PyObject *) NULL ;
39044 wxSizerItem *result;
39045 PyObject * obj0 = 0 ;
39046 PyObject * obj1 = 0 ;
39047 PyObject * obj2 = 0 ;
39048 PyObject * obj3 = 0 ;
39049 PyObject * obj4 = 0 ;
39050 char *kwnames[] = {
39051 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39052 };
39053
39054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39056 if (SWIG_arg_fail(1)) SWIG_fail;
39057 {
39058 arg2 = (int)(SWIG_As_int(obj1));
39059 if (SWIG_arg_fail(2)) SWIG_fail;
39060 }
39061 {
39062 arg3 = (int)(SWIG_As_int(obj2));
39063 if (SWIG_arg_fail(3)) SWIG_fail;
39064 }
39065 {
39066 arg4 = (int)(SWIG_As_int(obj3));
39067 if (SWIG_arg_fail(4)) SWIG_fail;
39068 }
39069 if (obj4) {
39070 arg5 = obj4;
39071 }
39072 {
39073 PyThreadState* __tstate = wxPyBeginAllowThreads();
39074 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39075
39076 wxPyEndAllowThreads(__tstate);
39077 if (PyErr_Occurred()) SWIG_fail;
39078 }
39079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39080 return resultobj;
39081 fail:
39082 return NULL;
39083 }
39084
39085
39086 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39087 PyObject *resultobj;
39088 int arg1 ;
39089 int arg2 ;
39090 int arg3 ;
39091 int arg4 ;
39092 int arg5 ;
39093 PyObject *arg6 = (PyObject *) NULL ;
39094 wxSizerItem *result;
39095 PyObject * obj0 = 0 ;
39096 PyObject * obj1 = 0 ;
39097 PyObject * obj2 = 0 ;
39098 PyObject * obj3 = 0 ;
39099 PyObject * obj4 = 0 ;
39100 PyObject * obj5 = 0 ;
39101 char *kwnames[] = {
39102 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39103 };
39104
39105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39106 {
39107 arg1 = (int)(SWIG_As_int(obj0));
39108 if (SWIG_arg_fail(1)) SWIG_fail;
39109 }
39110 {
39111 arg2 = (int)(SWIG_As_int(obj1));
39112 if (SWIG_arg_fail(2)) SWIG_fail;
39113 }
39114 {
39115 arg3 = (int)(SWIG_As_int(obj2));
39116 if (SWIG_arg_fail(3)) SWIG_fail;
39117 }
39118 {
39119 arg4 = (int)(SWIG_As_int(obj3));
39120 if (SWIG_arg_fail(4)) SWIG_fail;
39121 }
39122 {
39123 arg5 = (int)(SWIG_As_int(obj4));
39124 if (SWIG_arg_fail(5)) SWIG_fail;
39125 }
39126 if (obj5) {
39127 arg6 = obj5;
39128 }
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxSizer *arg1 = (wxSizer *) 0 ;
39146 int arg2 ;
39147 int arg3 ;
39148 int arg4 ;
39149 PyObject *arg5 = (PyObject *) NULL ;
39150 wxSizerItem *result;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 PyObject * obj3 = 0 ;
39155 PyObject * obj4 = 0 ;
39156 char *kwnames[] = {
39157 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39158 };
39159
39160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39162 if (SWIG_arg_fail(1)) SWIG_fail;
39163 {
39164 arg2 = (int)(SWIG_As_int(obj1));
39165 if (SWIG_arg_fail(2)) SWIG_fail;
39166 }
39167 {
39168 arg3 = (int)(SWIG_As_int(obj2));
39169 if (SWIG_arg_fail(3)) SWIG_fail;
39170 }
39171 {
39172 arg4 = (int)(SWIG_As_int(obj3));
39173 if (SWIG_arg_fail(4)) SWIG_fail;
39174 }
39175 if (obj4) {
39176 arg5 = obj4;
39177 }
39178 {
39179 PyThreadState* __tstate = wxPyBeginAllowThreads();
39180 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39181
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39193 PyObject *resultobj;
39194 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39195 PyObject * obj0 = 0 ;
39196 char *kwnames[] = {
39197 (char *) "self", NULL
39198 };
39199
39200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39202 if (SWIG_arg_fail(1)) SWIG_fail;
39203 {
39204 PyThreadState* __tstate = wxPyBeginAllowThreads();
39205 (arg1)->DeleteWindows();
39206
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 Py_INCREF(Py_None); resultobj = Py_None;
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj;
39219 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39220 PyObject * obj0 = 0 ;
39221 char *kwnames[] = {
39222 (char *) "self", NULL
39223 };
39224
39225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39227 if (SWIG_arg_fail(1)) SWIG_fail;
39228 {
39229 PyThreadState* __tstate = wxPyBeginAllowThreads();
39230 (arg1)->DetachSizer();
39231
39232 wxPyEndAllowThreads(__tstate);
39233 if (PyErr_Occurred()) SWIG_fail;
39234 }
39235 Py_INCREF(Py_None); resultobj = Py_None;
39236 return resultobj;
39237 fail:
39238 return NULL;
39239 }
39240
39241
39242 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39243 PyObject *resultobj;
39244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39245 wxSize result;
39246 PyObject * obj0 = 0 ;
39247 char *kwnames[] = {
39248 (char *) "self", NULL
39249 };
39250
39251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39253 if (SWIG_arg_fail(1)) SWIG_fail;
39254 {
39255 PyThreadState* __tstate = wxPyBeginAllowThreads();
39256 result = (arg1)->GetSize();
39257
39258 wxPyEndAllowThreads(__tstate);
39259 if (PyErr_Occurred()) SWIG_fail;
39260 }
39261 {
39262 wxSize * resultptr;
39263 resultptr = new wxSize((wxSize &)(result));
39264 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39265 }
39266 return resultobj;
39267 fail:
39268 return NULL;
39269 }
39270
39271
39272 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39273 PyObject *resultobj;
39274 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39275 wxSize result;
39276 PyObject * obj0 = 0 ;
39277 char *kwnames[] = {
39278 (char *) "self", NULL
39279 };
39280
39281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39283 if (SWIG_arg_fail(1)) SWIG_fail;
39284 {
39285 PyThreadState* __tstate = wxPyBeginAllowThreads();
39286 result = (arg1)->CalcMin();
39287
39288 wxPyEndAllowThreads(__tstate);
39289 if (PyErr_Occurred()) SWIG_fail;
39290 }
39291 {
39292 wxSize * resultptr;
39293 resultptr = new wxSize((wxSize &)(result));
39294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39295 }
39296 return resultobj;
39297 fail:
39298 return NULL;
39299 }
39300
39301
39302 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39303 PyObject *resultobj;
39304 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39305 wxPoint arg2 ;
39306 wxSize arg3 ;
39307 PyObject * obj0 = 0 ;
39308 PyObject * obj1 = 0 ;
39309 PyObject * obj2 = 0 ;
39310 char *kwnames[] = {
39311 (char *) "self",(char *) "pos",(char *) "size", NULL
39312 };
39313
39314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39316 if (SWIG_arg_fail(1)) SWIG_fail;
39317 {
39318 wxPoint * argp;
39319 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39320 if (SWIG_arg_fail(2)) SWIG_fail;
39321 if (argp == NULL) {
39322 SWIG_null_ref("wxPoint");
39323 }
39324 if (SWIG_arg_fail(2)) SWIG_fail;
39325 arg2 = *argp;
39326 }
39327 {
39328 wxSize * argp;
39329 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39330 if (SWIG_arg_fail(3)) SWIG_fail;
39331 if (argp == NULL) {
39332 SWIG_null_ref("wxSize");
39333 }
39334 if (SWIG_arg_fail(3)) SWIG_fail;
39335 arg3 = *argp;
39336 }
39337 {
39338 PyThreadState* __tstate = wxPyBeginAllowThreads();
39339 (arg1)->SetDimension(arg2,arg3);
39340
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 Py_INCREF(Py_None); resultobj = Py_None;
39345 return resultobj;
39346 fail:
39347 return NULL;
39348 }
39349
39350
39351 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39352 PyObject *resultobj;
39353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39354 wxSize result;
39355 PyObject * obj0 = 0 ;
39356 char *kwnames[] = {
39357 (char *) "self", NULL
39358 };
39359
39360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39362 if (SWIG_arg_fail(1)) SWIG_fail;
39363 {
39364 PyThreadState* __tstate = wxPyBeginAllowThreads();
39365 result = (arg1)->GetMinSize();
39366
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 {
39371 wxSize * resultptr;
39372 resultptr = new wxSize((wxSize &)(result));
39373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39374 }
39375 return resultobj;
39376 fail:
39377 return NULL;
39378 }
39379
39380
39381 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39382 PyObject *resultobj;
39383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39384 wxSize result;
39385 PyObject * obj0 = 0 ;
39386 char *kwnames[] = {
39387 (char *) "self", NULL
39388 };
39389
39390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39392 if (SWIG_arg_fail(1)) SWIG_fail;
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39396
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 {
39401 wxSize * resultptr;
39402 resultptr = new wxSize((wxSize &)(result));
39403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39404 }
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj;
39413 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39414 int arg2 ;
39415 int arg3 ;
39416 PyObject * obj0 = 0 ;
39417 PyObject * obj1 = 0 ;
39418 PyObject * obj2 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self",(char *) "x",(char *) "y", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 {
39427 arg2 = (int)(SWIG_As_int(obj1));
39428 if (SWIG_arg_fail(2)) SWIG_fail;
39429 }
39430 {
39431 arg3 = (int)(SWIG_As_int(obj2));
39432 if (SWIG_arg_fail(3)) SWIG_fail;
39433 }
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 (arg1)->SetInitSize(arg2,arg3);
39437
39438 wxPyEndAllowThreads(__tstate);
39439 if (PyErr_Occurred()) SWIG_fail;
39440 }
39441 Py_INCREF(Py_None); resultobj = Py_None;
39442 return resultobj;
39443 fail:
39444 return NULL;
39445 }
39446
39447
39448 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39449 PyObject *resultobj;
39450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39451 int arg2 ;
39452 int arg3 ;
39453 PyObject * obj0 = 0 ;
39454 PyObject * obj1 = 0 ;
39455 PyObject * obj2 = 0 ;
39456 char *kwnames[] = {
39457 (char *) "self",(char *) "width",(char *) "height", NULL
39458 };
39459
39460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39462 if (SWIG_arg_fail(1)) SWIG_fail;
39463 {
39464 arg2 = (int)(SWIG_As_int(obj1));
39465 if (SWIG_arg_fail(2)) SWIG_fail;
39466 }
39467 {
39468 arg3 = (int)(SWIG_As_int(obj2));
39469 if (SWIG_arg_fail(3)) SWIG_fail;
39470 }
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 (arg1)->SetRatio(arg2,arg3);
39474
39475 wxPyEndAllowThreads(__tstate);
39476 if (PyErr_Occurred()) SWIG_fail;
39477 }
39478 Py_INCREF(Py_None); resultobj = Py_None;
39479 return resultobj;
39480 fail:
39481 return NULL;
39482 }
39483
39484
39485 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39486 PyObject *resultobj;
39487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39488 wxSize *arg2 = 0 ;
39489 wxSize temp2 ;
39490 PyObject * obj0 = 0 ;
39491 PyObject * obj1 = 0 ;
39492 char *kwnames[] = {
39493 (char *) "self",(char *) "size", NULL
39494 };
39495
39496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39498 if (SWIG_arg_fail(1)) SWIG_fail;
39499 {
39500 arg2 = &temp2;
39501 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39502 }
39503 {
39504 PyThreadState* __tstate = wxPyBeginAllowThreads();
39505 (arg1)->SetRatio((wxSize const &)*arg2);
39506
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 Py_INCREF(Py_None); resultobj = Py_None;
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39518 PyObject *resultobj;
39519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39520 float arg2 ;
39521 PyObject * obj0 = 0 ;
39522 PyObject * obj1 = 0 ;
39523 char *kwnames[] = {
39524 (char *) "self",(char *) "ratio", NULL
39525 };
39526
39527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39529 if (SWIG_arg_fail(1)) SWIG_fail;
39530 {
39531 arg2 = (float)(SWIG_As_float(obj1));
39532 if (SWIG_arg_fail(2)) SWIG_fail;
39533 }
39534 {
39535 PyThreadState* __tstate = wxPyBeginAllowThreads();
39536 (arg1)->SetRatio(arg2);
39537
39538 wxPyEndAllowThreads(__tstate);
39539 if (PyErr_Occurred()) SWIG_fail;
39540 }
39541 Py_INCREF(Py_None); resultobj = Py_None;
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj;
39550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39551 float result;
39552 PyObject * obj0 = 0 ;
39553 char *kwnames[] = {
39554 (char *) "self", NULL
39555 };
39556
39557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39559 if (SWIG_arg_fail(1)) SWIG_fail;
39560 {
39561 PyThreadState* __tstate = wxPyBeginAllowThreads();
39562 result = (float)(arg1)->GetRatio();
39563
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = SWIG_From_float((float)(result));
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39577 PyObject *resultobj;
39578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39579 wxRect result;
39580 PyObject * obj0 = 0 ;
39581 char *kwnames[] = {
39582 (char *) "self", NULL
39583 };
39584
39585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39587 if (SWIG_arg_fail(1)) SWIG_fail;
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 result = (arg1)->GetRect();
39591
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 {
39596 wxRect * resultptr;
39597 resultptr = new wxRect((wxRect &)(result));
39598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39599 }
39600 return resultobj;
39601 fail:
39602 return NULL;
39603 }
39604
39605
39606 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39607 PyObject *resultobj;
39608 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39609 bool result;
39610 PyObject * obj0 = 0 ;
39611 char *kwnames[] = {
39612 (char *) "self", NULL
39613 };
39614
39615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39617 if (SWIG_arg_fail(1)) SWIG_fail;
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 result = (bool)(arg1)->IsWindow();
39621
39622 wxPyEndAllowThreads(__tstate);
39623 if (PyErr_Occurred()) SWIG_fail;
39624 }
39625 {
39626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39627 }
39628 return resultobj;
39629 fail:
39630 return NULL;
39631 }
39632
39633
39634 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39635 PyObject *resultobj;
39636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39637 bool result;
39638 PyObject * obj0 = 0 ;
39639 char *kwnames[] = {
39640 (char *) "self", NULL
39641 };
39642
39643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39645 if (SWIG_arg_fail(1)) SWIG_fail;
39646 {
39647 PyThreadState* __tstate = wxPyBeginAllowThreads();
39648 result = (bool)(arg1)->IsSizer();
39649
39650 wxPyEndAllowThreads(__tstate);
39651 if (PyErr_Occurred()) SWIG_fail;
39652 }
39653 {
39654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39655 }
39656 return resultobj;
39657 fail:
39658 return NULL;
39659 }
39660
39661
39662 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj;
39664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39665 bool result;
39666 PyObject * obj0 = 0 ;
39667 char *kwnames[] = {
39668 (char *) "self", NULL
39669 };
39670
39671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39673 if (SWIG_arg_fail(1)) SWIG_fail;
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (bool)(arg1)->IsSpacer();
39677
39678 wxPyEndAllowThreads(__tstate);
39679 if (PyErr_Occurred()) SWIG_fail;
39680 }
39681 {
39682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39683 }
39684 return resultobj;
39685 fail:
39686 return NULL;
39687 }
39688
39689
39690 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39691 PyObject *resultobj;
39692 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39693 int arg2 ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 char *kwnames[] = {
39697 (char *) "self",(char *) "proportion", NULL
39698 };
39699
39700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39702 if (SWIG_arg_fail(1)) SWIG_fail;
39703 {
39704 arg2 = (int)(SWIG_As_int(obj1));
39705 if (SWIG_arg_fail(2)) SWIG_fail;
39706 }
39707 {
39708 PyThreadState* __tstate = wxPyBeginAllowThreads();
39709 (arg1)->SetProportion(arg2);
39710
39711 wxPyEndAllowThreads(__tstate);
39712 if (PyErr_Occurred()) SWIG_fail;
39713 }
39714 Py_INCREF(Py_None); resultobj = Py_None;
39715 return resultobj;
39716 fail:
39717 return NULL;
39718 }
39719
39720
39721 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39722 PyObject *resultobj;
39723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39724 int result;
39725 PyObject * obj0 = 0 ;
39726 char *kwnames[] = {
39727 (char *) "self", NULL
39728 };
39729
39730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39732 if (SWIG_arg_fail(1)) SWIG_fail;
39733 {
39734 PyThreadState* __tstate = wxPyBeginAllowThreads();
39735 result = (int)(arg1)->GetProportion();
39736
39737 wxPyEndAllowThreads(__tstate);
39738 if (PyErr_Occurred()) SWIG_fail;
39739 }
39740 {
39741 resultobj = SWIG_From_int((int)(result));
39742 }
39743 return resultobj;
39744 fail:
39745 return NULL;
39746 }
39747
39748
39749 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39750 PyObject *resultobj;
39751 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39752 int arg2 ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 char *kwnames[] = {
39756 (char *) "self",(char *) "flag", NULL
39757 };
39758
39759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39761 if (SWIG_arg_fail(1)) SWIG_fail;
39762 {
39763 arg2 = (int)(SWIG_As_int(obj1));
39764 if (SWIG_arg_fail(2)) SWIG_fail;
39765 }
39766 {
39767 PyThreadState* __tstate = wxPyBeginAllowThreads();
39768 (arg1)->SetFlag(arg2);
39769
39770 wxPyEndAllowThreads(__tstate);
39771 if (PyErr_Occurred()) SWIG_fail;
39772 }
39773 Py_INCREF(Py_None); resultobj = Py_None;
39774 return resultobj;
39775 fail:
39776 return NULL;
39777 }
39778
39779
39780 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39781 PyObject *resultobj;
39782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39783 int result;
39784 PyObject * obj0 = 0 ;
39785 char *kwnames[] = {
39786 (char *) "self", NULL
39787 };
39788
39789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39791 if (SWIG_arg_fail(1)) SWIG_fail;
39792 {
39793 PyThreadState* __tstate = wxPyBeginAllowThreads();
39794 result = (int)(arg1)->GetFlag();
39795
39796 wxPyEndAllowThreads(__tstate);
39797 if (PyErr_Occurred()) SWIG_fail;
39798 }
39799 {
39800 resultobj = SWIG_From_int((int)(result));
39801 }
39802 return resultobj;
39803 fail:
39804 return NULL;
39805 }
39806
39807
39808 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39809 PyObject *resultobj;
39810 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39811 int arg2 ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 char *kwnames[] = {
39815 (char *) "self",(char *) "border", NULL
39816 };
39817
39818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(1)) SWIG_fail;
39821 {
39822 arg2 = (int)(SWIG_As_int(obj1));
39823 if (SWIG_arg_fail(2)) SWIG_fail;
39824 }
39825 {
39826 PyThreadState* __tstate = wxPyBeginAllowThreads();
39827 (arg1)->SetBorder(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_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39840 PyObject *resultobj;
39841 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39842 int result;
39843 PyObject * obj0 = 0 ;
39844 char *kwnames[] = {
39845 (char *) "self", NULL
39846 };
39847
39848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39850 if (SWIG_arg_fail(1)) SWIG_fail;
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 result = (int)(arg1)->GetBorder();
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 {
39859 resultobj = SWIG_From_int((int)(result));
39860 }
39861 return resultobj;
39862 fail:
39863 return NULL;
39864 }
39865
39866
39867 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39868 PyObject *resultobj;
39869 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39870 wxWindow *result;
39871 PyObject * obj0 = 0 ;
39872 char *kwnames[] = {
39873 (char *) "self", NULL
39874 };
39875
39876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39878 if (SWIG_arg_fail(1)) SWIG_fail;
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (wxWindow *)(arg1)->GetWindow();
39882
39883 wxPyEndAllowThreads(__tstate);
39884 if (PyErr_Occurred()) SWIG_fail;
39885 }
39886 {
39887 resultobj = wxPyMake_wxObject(result, 0);
39888 }
39889 return resultobj;
39890 fail:
39891 return NULL;
39892 }
39893
39894
39895 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39896 PyObject *resultobj;
39897 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39898 wxWindow *arg2 = (wxWindow *) 0 ;
39899 PyObject * obj0 = 0 ;
39900 PyObject * obj1 = 0 ;
39901 char *kwnames[] = {
39902 (char *) "self",(char *) "window", NULL
39903 };
39904
39905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39907 if (SWIG_arg_fail(1)) SWIG_fail;
39908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39909 if (SWIG_arg_fail(2)) SWIG_fail;
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 (arg1)->SetWindow(arg2);
39913
39914 wxPyEndAllowThreads(__tstate);
39915 if (PyErr_Occurred()) SWIG_fail;
39916 }
39917 Py_INCREF(Py_None); resultobj = Py_None;
39918 return resultobj;
39919 fail:
39920 return NULL;
39921 }
39922
39923
39924 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39925 PyObject *resultobj;
39926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39927 wxSizer *result;
39928 PyObject * obj0 = 0 ;
39929 char *kwnames[] = {
39930 (char *) "self", NULL
39931 };
39932
39933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39935 if (SWIG_arg_fail(1)) SWIG_fail;
39936 {
39937 PyThreadState* __tstate = wxPyBeginAllowThreads();
39938 result = (wxSizer *)(arg1)->GetSizer();
39939
39940 wxPyEndAllowThreads(__tstate);
39941 if (PyErr_Occurred()) SWIG_fail;
39942 }
39943 {
39944 resultobj = wxPyMake_wxObject(result, 0);
39945 }
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj;
39954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39955 wxSizer *arg2 = (wxSizer *) 0 ;
39956 PyObject * obj0 = 0 ;
39957 PyObject * obj1 = 0 ;
39958 char *kwnames[] = {
39959 (char *) "self",(char *) "sizer", NULL
39960 };
39961
39962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39964 if (SWIG_arg_fail(1)) SWIG_fail;
39965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39966 if (SWIG_arg_fail(2)) SWIG_fail;
39967 {
39968 PyThreadState* __tstate = wxPyBeginAllowThreads();
39969 (arg1)->SetSizer(arg2);
39970
39971 wxPyEndAllowThreads(__tstate);
39972 if (PyErr_Occurred()) SWIG_fail;
39973 }
39974 Py_INCREF(Py_None); resultobj = Py_None;
39975 return resultobj;
39976 fail:
39977 return NULL;
39978 }
39979
39980
39981 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39982 PyObject *resultobj;
39983 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39984 wxSize *result;
39985 PyObject * obj0 = 0 ;
39986 char *kwnames[] = {
39987 (char *) "self", NULL
39988 };
39989
39990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39992 if (SWIG_arg_fail(1)) SWIG_fail;
39993 {
39994 PyThreadState* __tstate = wxPyBeginAllowThreads();
39995 {
39996 wxSize const &_result_ref = (arg1)->GetSpacer();
39997 result = (wxSize *) &_result_ref;
39998 }
39999
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40011 PyObject *resultobj;
40012 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40013 wxSize *arg2 = 0 ;
40014 wxSize temp2 ;
40015 PyObject * obj0 = 0 ;
40016 PyObject * obj1 = 0 ;
40017 char *kwnames[] = {
40018 (char *) "self",(char *) "size", NULL
40019 };
40020
40021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40023 if (SWIG_arg_fail(1)) SWIG_fail;
40024 {
40025 arg2 = &temp2;
40026 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40027 }
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 (arg1)->SetSpacer((wxSize const &)*arg2);
40031
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 Py_INCREF(Py_None); resultobj = Py_None;
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj;
40044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40045 bool arg2 ;
40046 PyObject * obj0 = 0 ;
40047 PyObject * obj1 = 0 ;
40048 char *kwnames[] = {
40049 (char *) "self",(char *) "show", NULL
40050 };
40051
40052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40054 if (SWIG_arg_fail(1)) SWIG_fail;
40055 {
40056 arg2 = (bool)(SWIG_As_bool(obj1));
40057 if (SWIG_arg_fail(2)) SWIG_fail;
40058 }
40059 {
40060 PyThreadState* __tstate = wxPyBeginAllowThreads();
40061 (arg1)->Show(arg2);
40062
40063 wxPyEndAllowThreads(__tstate);
40064 if (PyErr_Occurred()) SWIG_fail;
40065 }
40066 Py_INCREF(Py_None); resultobj = Py_None;
40067 return resultobj;
40068 fail:
40069 return NULL;
40070 }
40071
40072
40073 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40074 PyObject *resultobj;
40075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40076 bool result;
40077 PyObject * obj0 = 0 ;
40078 char *kwnames[] = {
40079 (char *) "self", NULL
40080 };
40081
40082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40084 if (SWIG_arg_fail(1)) SWIG_fail;
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 result = (bool)(arg1)->IsShown();
40088
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 {
40093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40094 }
40095 return resultobj;
40096 fail:
40097 return NULL;
40098 }
40099
40100
40101 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40102 PyObject *resultobj;
40103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40104 wxPoint result;
40105 PyObject * obj0 = 0 ;
40106 char *kwnames[] = {
40107 (char *) "self", NULL
40108 };
40109
40110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40112 if (SWIG_arg_fail(1)) SWIG_fail;
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 result = (arg1)->GetPosition();
40116
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 {
40121 wxPoint * resultptr;
40122 resultptr = new wxPoint((wxPoint &)(result));
40123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40124 }
40125 return resultobj;
40126 fail:
40127 return NULL;
40128 }
40129
40130
40131 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40132 PyObject *resultobj;
40133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40134 PyObject *result;
40135 PyObject * obj0 = 0 ;
40136 char *kwnames[] = {
40137 (char *) "self", NULL
40138 };
40139
40140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40142 if (SWIG_arg_fail(1)) SWIG_fail;
40143 {
40144 PyThreadState* __tstate = wxPyBeginAllowThreads();
40145 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40146
40147 wxPyEndAllowThreads(__tstate);
40148 if (PyErr_Occurred()) SWIG_fail;
40149 }
40150 resultobj = result;
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40158 PyObject *obj;
40159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40160 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40161 Py_INCREF(obj);
40162 return Py_BuildValue((char *)"");
40163 }
40164 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40165 PyObject *resultobj;
40166 wxSizer *arg1 = (wxSizer *) 0 ;
40167 PyObject *arg2 = (PyObject *) 0 ;
40168 PyObject * obj0 = 0 ;
40169 PyObject * obj1 = 0 ;
40170 char *kwnames[] = {
40171 (char *) "self",(char *) "_self", NULL
40172 };
40173
40174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40176 if (SWIG_arg_fail(1)) SWIG_fail;
40177 arg2 = obj1;
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 wxSizer__setOORInfo(arg1,arg2);
40181
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 Py_INCREF(Py_None); resultobj = Py_None;
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj;
40194 wxSizer *arg1 = (wxSizer *) 0 ;
40195 PyObject *arg2 = (PyObject *) 0 ;
40196 int arg3 = (int) 0 ;
40197 int arg4 = (int) 0 ;
40198 int arg5 = (int) 0 ;
40199 PyObject *arg6 = (PyObject *) NULL ;
40200 wxSizerItem *result;
40201 PyObject * obj0 = 0 ;
40202 PyObject * obj1 = 0 ;
40203 PyObject * obj2 = 0 ;
40204 PyObject * obj3 = 0 ;
40205 PyObject * obj4 = 0 ;
40206 PyObject * obj5 = 0 ;
40207 char *kwnames[] = {
40208 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40209 };
40210
40211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40213 if (SWIG_arg_fail(1)) SWIG_fail;
40214 arg2 = obj1;
40215 if (obj2) {
40216 {
40217 arg3 = (int)(SWIG_As_int(obj2));
40218 if (SWIG_arg_fail(3)) SWIG_fail;
40219 }
40220 }
40221 if (obj3) {
40222 {
40223 arg4 = (int)(SWIG_As_int(obj3));
40224 if (SWIG_arg_fail(4)) SWIG_fail;
40225 }
40226 }
40227 if (obj4) {
40228 {
40229 arg5 = (int)(SWIG_As_int(obj4));
40230 if (SWIG_arg_fail(5)) SWIG_fail;
40231 }
40232 }
40233 if (obj5) {
40234 arg6 = obj5;
40235 }
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40239
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40244 return resultobj;
40245 fail:
40246 return NULL;
40247 }
40248
40249
40250 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40251 PyObject *resultobj;
40252 wxSizer *arg1 = (wxSizer *) 0 ;
40253 int arg2 ;
40254 PyObject *arg3 = (PyObject *) 0 ;
40255 int arg4 = (int) 0 ;
40256 int arg5 = (int) 0 ;
40257 int arg6 = (int) 0 ;
40258 PyObject *arg7 = (PyObject *) NULL ;
40259 wxSizerItem *result;
40260 PyObject * obj0 = 0 ;
40261 PyObject * obj1 = 0 ;
40262 PyObject * obj2 = 0 ;
40263 PyObject * obj3 = 0 ;
40264 PyObject * obj4 = 0 ;
40265 PyObject * obj5 = 0 ;
40266 PyObject * obj6 = 0 ;
40267 char *kwnames[] = {
40268 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40269 };
40270
40271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40273 if (SWIG_arg_fail(1)) SWIG_fail;
40274 {
40275 arg2 = (int)(SWIG_As_int(obj1));
40276 if (SWIG_arg_fail(2)) SWIG_fail;
40277 }
40278 arg3 = obj2;
40279 if (obj3) {
40280 {
40281 arg4 = (int)(SWIG_As_int(obj3));
40282 if (SWIG_arg_fail(4)) SWIG_fail;
40283 }
40284 }
40285 if (obj4) {
40286 {
40287 arg5 = (int)(SWIG_As_int(obj4));
40288 if (SWIG_arg_fail(5)) SWIG_fail;
40289 }
40290 }
40291 if (obj5) {
40292 {
40293 arg6 = (int)(SWIG_As_int(obj5));
40294 if (SWIG_arg_fail(6)) SWIG_fail;
40295 }
40296 }
40297 if (obj6) {
40298 arg7 = obj6;
40299 }
40300 {
40301 PyThreadState* __tstate = wxPyBeginAllowThreads();
40302 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40303
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj;
40316 wxSizer *arg1 = (wxSizer *) 0 ;
40317 PyObject *arg2 = (PyObject *) 0 ;
40318 int arg3 = (int) 0 ;
40319 int arg4 = (int) 0 ;
40320 int arg5 = (int) 0 ;
40321 PyObject *arg6 = (PyObject *) NULL ;
40322 wxSizerItem *result;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 PyObject * obj2 = 0 ;
40326 PyObject * obj3 = 0 ;
40327 PyObject * obj4 = 0 ;
40328 PyObject * obj5 = 0 ;
40329 char *kwnames[] = {
40330 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40331 };
40332
40333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40335 if (SWIG_arg_fail(1)) SWIG_fail;
40336 arg2 = obj1;
40337 if (obj2) {
40338 {
40339 arg3 = (int)(SWIG_As_int(obj2));
40340 if (SWIG_arg_fail(3)) SWIG_fail;
40341 }
40342 }
40343 if (obj3) {
40344 {
40345 arg4 = (int)(SWIG_As_int(obj3));
40346 if (SWIG_arg_fail(4)) SWIG_fail;
40347 }
40348 }
40349 if (obj4) {
40350 {
40351 arg5 = (int)(SWIG_As_int(obj4));
40352 if (SWIG_arg_fail(5)) SWIG_fail;
40353 }
40354 }
40355 if (obj5) {
40356 arg6 = obj5;
40357 }
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40361
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj;
40374 wxSizer *arg1 = (wxSizer *) 0 ;
40375 PyObject *arg2 = (PyObject *) 0 ;
40376 bool result;
40377 PyObject * obj0 = 0 ;
40378 PyObject * obj1 = 0 ;
40379 char *kwnames[] = {
40380 (char *) "self",(char *) "item", NULL
40381 };
40382
40383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40385 if (SWIG_arg_fail(1)) SWIG_fail;
40386 arg2 = obj1;
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 result = (bool)wxSizer_Remove(arg1,arg2);
40390
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 {
40395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40396 }
40397 return resultobj;
40398 fail:
40399 return NULL;
40400 }
40401
40402
40403 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40404 PyObject *resultobj;
40405 wxSizer *arg1 = (wxSizer *) 0 ;
40406 PyObject *arg2 = (PyObject *) 0 ;
40407 bool result;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char *kwnames[] = {
40411 (char *) "self",(char *) "item", NULL
40412 };
40413
40414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40416 if (SWIG_arg_fail(1)) SWIG_fail;
40417 arg2 = obj1;
40418 {
40419 PyThreadState* __tstate = wxPyBeginAllowThreads();
40420 result = (bool)wxSizer_Detach(arg1,arg2);
40421
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40435 PyObject *resultobj;
40436 wxSizer *arg1 = (wxSizer *) 0 ;
40437 PyObject *arg2 = (PyObject *) 0 ;
40438 wxSizerItem *result;
40439 PyObject * obj0 = 0 ;
40440 PyObject * obj1 = 0 ;
40441 char *kwnames[] = {
40442 (char *) "self",(char *) "item", NULL
40443 };
40444
40445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40447 if (SWIG_arg_fail(1)) SWIG_fail;
40448 arg2 = obj1;
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40452
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40457 return resultobj;
40458 fail:
40459 return NULL;
40460 }
40461
40462
40463 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40464 PyObject *resultobj;
40465 wxSizer *arg1 = (wxSizer *) 0 ;
40466 PyObject *arg2 = (PyObject *) 0 ;
40467 wxSize *arg3 = 0 ;
40468 wxSize temp3 ;
40469 PyObject * obj0 = 0 ;
40470 PyObject * obj1 = 0 ;
40471 PyObject * obj2 = 0 ;
40472 char *kwnames[] = {
40473 (char *) "self",(char *) "item",(char *) "size", NULL
40474 };
40475
40476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40478 if (SWIG_arg_fail(1)) SWIG_fail;
40479 arg2 = obj1;
40480 {
40481 arg3 = &temp3;
40482 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40483 }
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40487
40488 wxPyEndAllowThreads(__tstate);
40489 if (PyErr_Occurred()) SWIG_fail;
40490 }
40491 Py_INCREF(Py_None); resultobj = Py_None;
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40499 PyObject *resultobj;
40500 wxSizer *arg1 = (wxSizer *) 0 ;
40501 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40502 wxSizerItem *result;
40503 PyObject * obj0 = 0 ;
40504 PyObject * obj1 = 0 ;
40505 char *kwnames[] = {
40506 (char *) "self",(char *) "item", NULL
40507 };
40508
40509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40511 if (SWIG_arg_fail(1)) SWIG_fail;
40512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(2)) SWIG_fail;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (wxSizerItem *)(arg1)->Add(arg2);
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40529 PyObject *resultobj;
40530 wxSizer *arg1 = (wxSizer *) 0 ;
40531 size_t arg2 ;
40532 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40533 wxSizerItem *result;
40534 PyObject * obj0 = 0 ;
40535 PyObject * obj1 = 0 ;
40536 PyObject * obj2 = 0 ;
40537 char *kwnames[] = {
40538 (char *) "self",(char *) "index",(char *) "item", NULL
40539 };
40540
40541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40543 if (SWIG_arg_fail(1)) SWIG_fail;
40544 {
40545 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40546 if (SWIG_arg_fail(2)) SWIG_fail;
40547 }
40548 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40549 if (SWIG_arg_fail(3)) SWIG_fail;
40550 {
40551 PyThreadState* __tstate = wxPyBeginAllowThreads();
40552 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40553
40554 wxPyEndAllowThreads(__tstate);
40555 if (PyErr_Occurred()) SWIG_fail;
40556 }
40557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40558 return resultobj;
40559 fail:
40560 return NULL;
40561 }
40562
40563
40564 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40565 PyObject *resultobj;
40566 wxSizer *arg1 = (wxSizer *) 0 ;
40567 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40568 wxSizerItem *result;
40569 PyObject * obj0 = 0 ;
40570 PyObject * obj1 = 0 ;
40571 char *kwnames[] = {
40572 (char *) "self",(char *) "item", NULL
40573 };
40574
40575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40577 if (SWIG_arg_fail(1)) SWIG_fail;
40578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40579 if (SWIG_arg_fail(2)) SWIG_fail;
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40583
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40588 return resultobj;
40589 fail:
40590 return NULL;
40591 }
40592
40593
40594 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40595 PyObject *resultobj;
40596 wxSizer *arg1 = (wxSizer *) 0 ;
40597 int arg2 ;
40598 int arg3 ;
40599 int arg4 ;
40600 int arg5 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 PyObject * obj2 = 0 ;
40604 PyObject * obj3 = 0 ;
40605 PyObject * obj4 = 0 ;
40606 char *kwnames[] = {
40607 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40608 };
40609
40610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40612 if (SWIG_arg_fail(1)) SWIG_fail;
40613 {
40614 arg2 = (int)(SWIG_As_int(obj1));
40615 if (SWIG_arg_fail(2)) SWIG_fail;
40616 }
40617 {
40618 arg3 = (int)(SWIG_As_int(obj2));
40619 if (SWIG_arg_fail(3)) SWIG_fail;
40620 }
40621 {
40622 arg4 = (int)(SWIG_As_int(obj3));
40623 if (SWIG_arg_fail(4)) SWIG_fail;
40624 }
40625 {
40626 arg5 = (int)(SWIG_As_int(obj4));
40627 if (SWIG_arg_fail(5)) SWIG_fail;
40628 }
40629 {
40630 PyThreadState* __tstate = wxPyBeginAllowThreads();
40631 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40632
40633 wxPyEndAllowThreads(__tstate);
40634 if (PyErr_Occurred()) SWIG_fail;
40635 }
40636 Py_INCREF(Py_None); resultobj = Py_None;
40637 return resultobj;
40638 fail:
40639 return NULL;
40640 }
40641
40642
40643 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40644 PyObject *resultobj;
40645 wxSizer *arg1 = (wxSizer *) 0 ;
40646 wxSize *arg2 = 0 ;
40647 wxSize temp2 ;
40648 PyObject * obj0 = 0 ;
40649 PyObject * obj1 = 0 ;
40650 char *kwnames[] = {
40651 (char *) "self",(char *) "size", NULL
40652 };
40653
40654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40656 if (SWIG_arg_fail(1)) SWIG_fail;
40657 {
40658 arg2 = &temp2;
40659 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40660 }
40661 {
40662 PyThreadState* __tstate = wxPyBeginAllowThreads();
40663 (arg1)->SetMinSize((wxSize const &)*arg2);
40664
40665 wxPyEndAllowThreads(__tstate);
40666 if (PyErr_Occurred()) SWIG_fail;
40667 }
40668 Py_INCREF(Py_None); resultobj = Py_None;
40669 return resultobj;
40670 fail:
40671 return NULL;
40672 }
40673
40674
40675 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40676 PyObject *resultobj;
40677 wxSizer *arg1 = (wxSizer *) 0 ;
40678 wxSize result;
40679 PyObject * obj0 = 0 ;
40680 char *kwnames[] = {
40681 (char *) "self", NULL
40682 };
40683
40684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40686 if (SWIG_arg_fail(1)) SWIG_fail;
40687 {
40688 PyThreadState* __tstate = wxPyBeginAllowThreads();
40689 result = (arg1)->GetSize();
40690
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 {
40695 wxSize * resultptr;
40696 resultptr = new wxSize((wxSize &)(result));
40697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40698 }
40699 return resultobj;
40700 fail:
40701 return NULL;
40702 }
40703
40704
40705 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40706 PyObject *resultobj;
40707 wxSizer *arg1 = (wxSizer *) 0 ;
40708 wxPoint result;
40709 PyObject * obj0 = 0 ;
40710 char *kwnames[] = {
40711 (char *) "self", NULL
40712 };
40713
40714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40716 if (SWIG_arg_fail(1)) SWIG_fail;
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (arg1)->GetPosition();
40720
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 {
40725 wxPoint * resultptr;
40726 resultptr = new wxPoint((wxPoint &)(result));
40727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40728 }
40729 return resultobj;
40730 fail:
40731 return NULL;
40732 }
40733
40734
40735 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40736 PyObject *resultobj;
40737 wxSizer *arg1 = (wxSizer *) 0 ;
40738 wxSize result;
40739 PyObject * obj0 = 0 ;
40740 char *kwnames[] = {
40741 (char *) "self", NULL
40742 };
40743
40744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40746 if (SWIG_arg_fail(1)) SWIG_fail;
40747 {
40748 PyThreadState* __tstate = wxPyBeginAllowThreads();
40749 result = (arg1)->GetMinSize();
40750
40751 wxPyEndAllowThreads(__tstate);
40752 if (PyErr_Occurred()) SWIG_fail;
40753 }
40754 {
40755 wxSize * resultptr;
40756 resultptr = new wxSize((wxSize &)(result));
40757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40758 }
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40766 PyObject *resultobj;
40767 wxSizer *arg1 = (wxSizer *) 0 ;
40768 PyObject * obj0 = 0 ;
40769 char *kwnames[] = {
40770 (char *) "self", NULL
40771 };
40772
40773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40775 if (SWIG_arg_fail(1)) SWIG_fail;
40776 {
40777 PyThreadState* __tstate = wxPyBeginAllowThreads();
40778 (arg1)->RecalcSizes();
40779
40780 wxPyEndAllowThreads(__tstate);
40781 if (PyErr_Occurred()) SWIG_fail;
40782 }
40783 Py_INCREF(Py_None); resultobj = Py_None;
40784 return resultobj;
40785 fail:
40786 return NULL;
40787 }
40788
40789
40790 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40791 PyObject *resultobj;
40792 wxSizer *arg1 = (wxSizer *) 0 ;
40793 wxSize result;
40794 PyObject * obj0 = 0 ;
40795 char *kwnames[] = {
40796 (char *) "self", NULL
40797 };
40798
40799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40801 if (SWIG_arg_fail(1)) SWIG_fail;
40802 {
40803 PyThreadState* __tstate = wxPyBeginAllowThreads();
40804 result = (arg1)->CalcMin();
40805
40806 wxPyEndAllowThreads(__tstate);
40807 if (PyErr_Occurred()) SWIG_fail;
40808 }
40809 {
40810 wxSize * resultptr;
40811 resultptr = new wxSize((wxSize &)(result));
40812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40813 }
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40821 PyObject *resultobj;
40822 wxSizer *arg1 = (wxSizer *) 0 ;
40823 PyObject * obj0 = 0 ;
40824 char *kwnames[] = {
40825 (char *) "self", NULL
40826 };
40827
40828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40830 if (SWIG_arg_fail(1)) SWIG_fail;
40831 {
40832 PyThreadState* __tstate = wxPyBeginAllowThreads();
40833 (arg1)->Layout();
40834
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 Py_INCREF(Py_None); resultobj = Py_None;
40839 return resultobj;
40840 fail:
40841 return NULL;
40842 }
40843
40844
40845 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40846 PyObject *resultobj;
40847 wxSizer *arg1 = (wxSizer *) 0 ;
40848 wxWindow *arg2 = (wxWindow *) 0 ;
40849 wxSize result;
40850 PyObject * obj0 = 0 ;
40851 PyObject * obj1 = 0 ;
40852 char *kwnames[] = {
40853 (char *) "self",(char *) "window", NULL
40854 };
40855
40856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40858 if (SWIG_arg_fail(1)) SWIG_fail;
40859 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40860 if (SWIG_arg_fail(2)) SWIG_fail;
40861 {
40862 PyThreadState* __tstate = wxPyBeginAllowThreads();
40863 result = (arg1)->Fit(arg2);
40864
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 {
40869 wxSize * resultptr;
40870 resultptr = new wxSize((wxSize &)(result));
40871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40872 }
40873 return resultobj;
40874 fail:
40875 return NULL;
40876 }
40877
40878
40879 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40880 PyObject *resultobj;
40881 wxSizer *arg1 = (wxSizer *) 0 ;
40882 wxWindow *arg2 = (wxWindow *) 0 ;
40883 PyObject * obj0 = 0 ;
40884 PyObject * obj1 = 0 ;
40885 char *kwnames[] = {
40886 (char *) "self",(char *) "window", NULL
40887 };
40888
40889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40891 if (SWIG_arg_fail(1)) SWIG_fail;
40892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(2)) SWIG_fail;
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 (arg1)->FitInside(arg2);
40897
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 Py_INCREF(Py_None); resultobj = Py_None;
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj;
40910 wxSizer *arg1 = (wxSizer *) 0 ;
40911 wxWindow *arg2 = (wxWindow *) 0 ;
40912 PyObject * obj0 = 0 ;
40913 PyObject * obj1 = 0 ;
40914 char *kwnames[] = {
40915 (char *) "self",(char *) "window", NULL
40916 };
40917
40918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40920 if (SWIG_arg_fail(1)) SWIG_fail;
40921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40922 if (SWIG_arg_fail(2)) SWIG_fail;
40923 {
40924 PyThreadState* __tstate = wxPyBeginAllowThreads();
40925 (arg1)->SetSizeHints(arg2);
40926
40927 wxPyEndAllowThreads(__tstate);
40928 if (PyErr_Occurred()) SWIG_fail;
40929 }
40930 Py_INCREF(Py_None); resultobj = Py_None;
40931 return resultobj;
40932 fail:
40933 return NULL;
40934 }
40935
40936
40937 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40938 PyObject *resultobj;
40939 wxSizer *arg1 = (wxSizer *) 0 ;
40940 wxWindow *arg2 = (wxWindow *) 0 ;
40941 PyObject * obj0 = 0 ;
40942 PyObject * obj1 = 0 ;
40943 char *kwnames[] = {
40944 (char *) "self",(char *) "window", NULL
40945 };
40946
40947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40949 if (SWIG_arg_fail(1)) SWIG_fail;
40950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40951 if (SWIG_arg_fail(2)) SWIG_fail;
40952 {
40953 PyThreadState* __tstate = wxPyBeginAllowThreads();
40954 (arg1)->SetVirtualSizeHints(arg2);
40955
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 Py_INCREF(Py_None); resultobj = Py_None;
40960 return resultobj;
40961 fail:
40962 return NULL;
40963 }
40964
40965
40966 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj;
40968 wxSizer *arg1 = (wxSizer *) 0 ;
40969 bool arg2 = (bool) false ;
40970 PyObject * obj0 = 0 ;
40971 PyObject * obj1 = 0 ;
40972 char *kwnames[] = {
40973 (char *) "self",(char *) "deleteWindows", NULL
40974 };
40975
40976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40978 if (SWIG_arg_fail(1)) SWIG_fail;
40979 if (obj1) {
40980 {
40981 arg2 = (bool)(SWIG_As_bool(obj1));
40982 if (SWIG_arg_fail(2)) SWIG_fail;
40983 }
40984 }
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 (arg1)->Clear(arg2);
40988
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 Py_INCREF(Py_None); resultobj = Py_None;
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj;
41001 wxSizer *arg1 = (wxSizer *) 0 ;
41002 PyObject * obj0 = 0 ;
41003 char *kwnames[] = {
41004 (char *) "self", NULL
41005 };
41006
41007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41009 if (SWIG_arg_fail(1)) SWIG_fail;
41010 {
41011 PyThreadState* __tstate = wxPyBeginAllowThreads();
41012 (arg1)->DeleteWindows();
41013
41014 wxPyEndAllowThreads(__tstate);
41015 if (PyErr_Occurred()) SWIG_fail;
41016 }
41017 Py_INCREF(Py_None); resultobj = Py_None;
41018 return resultobj;
41019 fail:
41020 return NULL;
41021 }
41022
41023
41024 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41025 PyObject *resultobj;
41026 wxSizer *arg1 = (wxSizer *) 0 ;
41027 PyObject *result;
41028 PyObject * obj0 = 0 ;
41029 char *kwnames[] = {
41030 (char *) "self", NULL
41031 };
41032
41033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41035 if (SWIG_arg_fail(1)) SWIG_fail;
41036 {
41037 PyThreadState* __tstate = wxPyBeginAllowThreads();
41038 result = (PyObject *)wxSizer_GetChildren(arg1);
41039
41040 wxPyEndAllowThreads(__tstate);
41041 if (PyErr_Occurred()) SWIG_fail;
41042 }
41043 resultobj = result;
41044 return resultobj;
41045 fail:
41046 return NULL;
41047 }
41048
41049
41050 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41051 PyObject *resultobj;
41052 wxSizer *arg1 = (wxSizer *) 0 ;
41053 PyObject *arg2 = (PyObject *) 0 ;
41054 bool arg3 = (bool) true ;
41055 bool arg4 = (bool) false ;
41056 bool result;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 PyObject * obj2 = 0 ;
41060 PyObject * obj3 = 0 ;
41061 char *kwnames[] = {
41062 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41063 };
41064
41065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41067 if (SWIG_arg_fail(1)) SWIG_fail;
41068 arg2 = obj1;
41069 if (obj2) {
41070 {
41071 arg3 = (bool)(SWIG_As_bool(obj2));
41072 if (SWIG_arg_fail(3)) SWIG_fail;
41073 }
41074 }
41075 if (obj3) {
41076 {
41077 arg4 = (bool)(SWIG_As_bool(obj3));
41078 if (SWIG_arg_fail(4)) SWIG_fail;
41079 }
41080 }
41081 {
41082 PyThreadState* __tstate = wxPyBeginAllowThreads();
41083 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41084
41085 wxPyEndAllowThreads(__tstate);
41086 if (PyErr_Occurred()) SWIG_fail;
41087 }
41088 {
41089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41090 }
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj;
41099 wxSizer *arg1 = (wxSizer *) 0 ;
41100 PyObject *arg2 = (PyObject *) 0 ;
41101 bool result;
41102 PyObject * obj0 = 0 ;
41103 PyObject * obj1 = 0 ;
41104 char *kwnames[] = {
41105 (char *) "self",(char *) "item", NULL
41106 };
41107
41108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41110 if (SWIG_arg_fail(1)) SWIG_fail;
41111 arg2 = obj1;
41112 {
41113 PyThreadState* __tstate = wxPyBeginAllowThreads();
41114 result = (bool)wxSizer_IsShown(arg1,arg2);
41115
41116 wxPyEndAllowThreads(__tstate);
41117 if (PyErr_Occurred()) SWIG_fail;
41118 }
41119 {
41120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41121 }
41122 return resultobj;
41123 fail:
41124 return NULL;
41125 }
41126
41127
41128 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj;
41130 wxSizer *arg1 = (wxSizer *) 0 ;
41131 bool arg2 ;
41132 PyObject * obj0 = 0 ;
41133 PyObject * obj1 = 0 ;
41134 char *kwnames[] = {
41135 (char *) "self",(char *) "show", NULL
41136 };
41137
41138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41140 if (SWIG_arg_fail(1)) SWIG_fail;
41141 {
41142 arg2 = (bool)(SWIG_As_bool(obj1));
41143 if (SWIG_arg_fail(2)) SWIG_fail;
41144 }
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 (arg1)->ShowItems(arg2);
41148
41149 wxPyEndAllowThreads(__tstate);
41150 if (PyErr_Occurred()) SWIG_fail;
41151 }
41152 Py_INCREF(Py_None); resultobj = Py_None;
41153 return resultobj;
41154 fail:
41155 return NULL;
41156 }
41157
41158
41159 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41160 PyObject *obj;
41161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41162 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41163 Py_INCREF(obj);
41164 return Py_BuildValue((char *)"");
41165 }
41166 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41167 PyObject *resultobj;
41168 wxPySizer *result;
41169 char *kwnames[] = {
41170 NULL
41171 };
41172
41173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41174 {
41175 PyThreadState* __tstate = wxPyBeginAllowThreads();
41176 result = (wxPySizer *)new wxPySizer();
41177
41178 wxPyEndAllowThreads(__tstate);
41179 if (PyErr_Occurred()) SWIG_fail;
41180 }
41181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41182 return resultobj;
41183 fail:
41184 return NULL;
41185 }
41186
41187
41188 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41189 PyObject *resultobj;
41190 wxPySizer *arg1 = (wxPySizer *) 0 ;
41191 PyObject *arg2 = (PyObject *) 0 ;
41192 PyObject *arg3 = (PyObject *) 0 ;
41193 PyObject * obj0 = 0 ;
41194 PyObject * obj1 = 0 ;
41195 PyObject * obj2 = 0 ;
41196 char *kwnames[] = {
41197 (char *) "self",(char *) "self",(char *) "_class", NULL
41198 };
41199
41200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41202 if (SWIG_arg_fail(1)) SWIG_fail;
41203 arg2 = obj1;
41204 arg3 = obj2;
41205 {
41206 PyThreadState* __tstate = wxPyBeginAllowThreads();
41207 (arg1)->_setCallbackInfo(arg2,arg3);
41208
41209 wxPyEndAllowThreads(__tstate);
41210 if (PyErr_Occurred()) SWIG_fail;
41211 }
41212 Py_INCREF(Py_None); resultobj = Py_None;
41213 return resultobj;
41214 fail:
41215 return NULL;
41216 }
41217
41218
41219 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41220 PyObject *obj;
41221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41222 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41223 Py_INCREF(obj);
41224 return Py_BuildValue((char *)"");
41225 }
41226 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 int arg1 = (int) wxHORIZONTAL ;
41229 wxBoxSizer *result;
41230 PyObject * obj0 = 0 ;
41231 char *kwnames[] = {
41232 (char *) "orient", NULL
41233 };
41234
41235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41236 if (obj0) {
41237 {
41238 arg1 = (int)(SWIG_As_int(obj0));
41239 if (SWIG_arg_fail(1)) SWIG_fail;
41240 }
41241 }
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41245
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41250 return resultobj;
41251 fail:
41252 return NULL;
41253 }
41254
41255
41256 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41257 PyObject *resultobj;
41258 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41259 int result;
41260 PyObject * obj0 = 0 ;
41261 char *kwnames[] = {
41262 (char *) "self", NULL
41263 };
41264
41265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41267 if (SWIG_arg_fail(1)) SWIG_fail;
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (int)(arg1)->GetOrientation();
41271
41272 wxPyEndAllowThreads(__tstate);
41273 if (PyErr_Occurred()) SWIG_fail;
41274 }
41275 {
41276 resultobj = SWIG_From_int((int)(result));
41277 }
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41287 int arg2 ;
41288 PyObject * obj0 = 0 ;
41289 PyObject * obj1 = 0 ;
41290 char *kwnames[] = {
41291 (char *) "self",(char *) "orient", NULL
41292 };
41293
41294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41296 if (SWIG_arg_fail(1)) SWIG_fail;
41297 {
41298 arg2 = (int)(SWIG_As_int(obj1));
41299 if (SWIG_arg_fail(2)) SWIG_fail;
41300 }
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 (arg1)->SetOrientation(arg2);
41304
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 Py_INCREF(Py_None); resultobj = Py_None;
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41316 PyObject *obj;
41317 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41318 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41319 Py_INCREF(obj);
41320 return Py_BuildValue((char *)"");
41321 }
41322 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41323 PyObject *resultobj;
41324 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41325 int arg2 = (int) wxHORIZONTAL ;
41326 wxStaticBoxSizer *result;
41327 PyObject * obj0 = 0 ;
41328 PyObject * obj1 = 0 ;
41329 char *kwnames[] = {
41330 (char *) "box",(char *) "orient", NULL
41331 };
41332
41333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41335 if (SWIG_arg_fail(1)) SWIG_fail;
41336 if (obj1) {
41337 {
41338 arg2 = (int)(SWIG_As_int(obj1));
41339 if (SWIG_arg_fail(2)) SWIG_fail;
41340 }
41341 }
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41345
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj;
41358 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41359 wxStaticBox *result;
41360 PyObject * obj0 = 0 ;
41361 char *kwnames[] = {
41362 (char *) "self", NULL
41363 };
41364
41365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41367 if (SWIG_arg_fail(1)) SWIG_fail;
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 result = (wxStaticBox *)(arg1)->GetStaticBox();
41371
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 {
41376 resultobj = wxPyMake_wxObject(result, 0);
41377 }
41378 return resultobj;
41379 fail:
41380 return NULL;
41381 }
41382
41383
41384 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41385 PyObject *obj;
41386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41387 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41388 Py_INCREF(obj);
41389 return Py_BuildValue((char *)"");
41390 }
41391 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj;
41393 int arg1 = (int) 1 ;
41394 int arg2 = (int) 0 ;
41395 int arg3 = (int) 0 ;
41396 int arg4 = (int) 0 ;
41397 wxGridSizer *result;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 PyObject * obj2 = 0 ;
41401 PyObject * obj3 = 0 ;
41402 char *kwnames[] = {
41403 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41404 };
41405
41406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41407 if (obj0) {
41408 {
41409 arg1 = (int)(SWIG_As_int(obj0));
41410 if (SWIG_arg_fail(1)) SWIG_fail;
41411 }
41412 }
41413 if (obj1) {
41414 {
41415 arg2 = (int)(SWIG_As_int(obj1));
41416 if (SWIG_arg_fail(2)) SWIG_fail;
41417 }
41418 }
41419 if (obj2) {
41420 {
41421 arg3 = (int)(SWIG_As_int(obj2));
41422 if (SWIG_arg_fail(3)) SWIG_fail;
41423 }
41424 }
41425 if (obj3) {
41426 {
41427 arg4 = (int)(SWIG_As_int(obj3));
41428 if (SWIG_arg_fail(4)) SWIG_fail;
41429 }
41430 }
41431 {
41432 PyThreadState* __tstate = wxPyBeginAllowThreads();
41433 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41434
41435 wxPyEndAllowThreads(__tstate);
41436 if (PyErr_Occurred()) SWIG_fail;
41437 }
41438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41439 return resultobj;
41440 fail:
41441 return NULL;
41442 }
41443
41444
41445 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41446 PyObject *resultobj;
41447 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41448 int arg2 ;
41449 PyObject * obj0 = 0 ;
41450 PyObject * obj1 = 0 ;
41451 char *kwnames[] = {
41452 (char *) "self",(char *) "cols", NULL
41453 };
41454
41455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41457 if (SWIG_arg_fail(1)) SWIG_fail;
41458 {
41459 arg2 = (int)(SWIG_As_int(obj1));
41460 if (SWIG_arg_fail(2)) SWIG_fail;
41461 }
41462 {
41463 PyThreadState* __tstate = wxPyBeginAllowThreads();
41464 (arg1)->SetCols(arg2);
41465
41466 wxPyEndAllowThreads(__tstate);
41467 if (PyErr_Occurred()) SWIG_fail;
41468 }
41469 Py_INCREF(Py_None); resultobj = Py_None;
41470 return resultobj;
41471 fail:
41472 return NULL;
41473 }
41474
41475
41476 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41477 PyObject *resultobj;
41478 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41479 int arg2 ;
41480 PyObject * obj0 = 0 ;
41481 PyObject * obj1 = 0 ;
41482 char *kwnames[] = {
41483 (char *) "self",(char *) "rows", NULL
41484 };
41485
41486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41488 if (SWIG_arg_fail(1)) SWIG_fail;
41489 {
41490 arg2 = (int)(SWIG_As_int(obj1));
41491 if (SWIG_arg_fail(2)) SWIG_fail;
41492 }
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 (arg1)->SetRows(arg2);
41496
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 Py_INCREF(Py_None); resultobj = Py_None;
41501 return resultobj;
41502 fail:
41503 return NULL;
41504 }
41505
41506
41507 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41508 PyObject *resultobj;
41509 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41510 int arg2 ;
41511 PyObject * obj0 = 0 ;
41512 PyObject * obj1 = 0 ;
41513 char *kwnames[] = {
41514 (char *) "self",(char *) "gap", NULL
41515 };
41516
41517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41519 if (SWIG_arg_fail(1)) SWIG_fail;
41520 {
41521 arg2 = (int)(SWIG_As_int(obj1));
41522 if (SWIG_arg_fail(2)) SWIG_fail;
41523 }
41524 {
41525 PyThreadState* __tstate = wxPyBeginAllowThreads();
41526 (arg1)->SetVGap(arg2);
41527
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 Py_INCREF(Py_None); resultobj = Py_None;
41532 return resultobj;
41533 fail:
41534 return NULL;
41535 }
41536
41537
41538 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj;
41540 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41541 int arg2 ;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 char *kwnames[] = {
41545 (char *) "self",(char *) "gap", NULL
41546 };
41547
41548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41550 if (SWIG_arg_fail(1)) SWIG_fail;
41551 {
41552 arg2 = (int)(SWIG_As_int(obj1));
41553 if (SWIG_arg_fail(2)) SWIG_fail;
41554 }
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 (arg1)->SetHGap(arg2);
41558
41559 wxPyEndAllowThreads(__tstate);
41560 if (PyErr_Occurred()) SWIG_fail;
41561 }
41562 Py_INCREF(Py_None); resultobj = Py_None;
41563 return resultobj;
41564 fail:
41565 return NULL;
41566 }
41567
41568
41569 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41570 PyObject *resultobj;
41571 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41572 int result;
41573 PyObject * obj0 = 0 ;
41574 char *kwnames[] = {
41575 (char *) "self", NULL
41576 };
41577
41578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41580 if (SWIG_arg_fail(1)) SWIG_fail;
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 result = (int)(arg1)->GetCols();
41584
41585 wxPyEndAllowThreads(__tstate);
41586 if (PyErr_Occurred()) SWIG_fail;
41587 }
41588 {
41589 resultobj = SWIG_From_int((int)(result));
41590 }
41591 return resultobj;
41592 fail:
41593 return NULL;
41594 }
41595
41596
41597 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41598 PyObject *resultobj;
41599 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41600 int result;
41601 PyObject * obj0 = 0 ;
41602 char *kwnames[] = {
41603 (char *) "self", NULL
41604 };
41605
41606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41608 if (SWIG_arg_fail(1)) SWIG_fail;
41609 {
41610 PyThreadState* __tstate = wxPyBeginAllowThreads();
41611 result = (int)(arg1)->GetRows();
41612
41613 wxPyEndAllowThreads(__tstate);
41614 if (PyErr_Occurred()) SWIG_fail;
41615 }
41616 {
41617 resultobj = SWIG_From_int((int)(result));
41618 }
41619 return resultobj;
41620 fail:
41621 return NULL;
41622 }
41623
41624
41625 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41626 PyObject *resultobj;
41627 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41628 int result;
41629 PyObject * obj0 = 0 ;
41630 char *kwnames[] = {
41631 (char *) "self", NULL
41632 };
41633
41634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41636 if (SWIG_arg_fail(1)) SWIG_fail;
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 result = (int)(arg1)->GetVGap();
41640
41641 wxPyEndAllowThreads(__tstate);
41642 if (PyErr_Occurred()) SWIG_fail;
41643 }
41644 {
41645 resultobj = SWIG_From_int((int)(result));
41646 }
41647 return resultobj;
41648 fail:
41649 return NULL;
41650 }
41651
41652
41653 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj;
41655 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41656 int result;
41657 PyObject * obj0 = 0 ;
41658 char *kwnames[] = {
41659 (char *) "self", NULL
41660 };
41661
41662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41664 if (SWIG_arg_fail(1)) SWIG_fail;
41665 {
41666 PyThreadState* __tstate = wxPyBeginAllowThreads();
41667 result = (int)(arg1)->GetHGap();
41668
41669 wxPyEndAllowThreads(__tstate);
41670 if (PyErr_Occurred()) SWIG_fail;
41671 }
41672 {
41673 resultobj = SWIG_From_int((int)(result));
41674 }
41675 return resultobj;
41676 fail:
41677 return NULL;
41678 }
41679
41680
41681 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41682 PyObject *obj;
41683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41684 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41685 Py_INCREF(obj);
41686 return Py_BuildValue((char *)"");
41687 }
41688 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41689 PyObject *resultobj;
41690 int arg1 = (int) 1 ;
41691 int arg2 = (int) 0 ;
41692 int arg3 = (int) 0 ;
41693 int arg4 = (int) 0 ;
41694 wxFlexGridSizer *result;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 PyObject * obj3 = 0 ;
41699 char *kwnames[] = {
41700 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41701 };
41702
41703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41704 if (obj0) {
41705 {
41706 arg1 = (int)(SWIG_As_int(obj0));
41707 if (SWIG_arg_fail(1)) SWIG_fail;
41708 }
41709 }
41710 if (obj1) {
41711 {
41712 arg2 = (int)(SWIG_As_int(obj1));
41713 if (SWIG_arg_fail(2)) SWIG_fail;
41714 }
41715 }
41716 if (obj2) {
41717 {
41718 arg3 = (int)(SWIG_As_int(obj2));
41719 if (SWIG_arg_fail(3)) SWIG_fail;
41720 }
41721 }
41722 if (obj3) {
41723 {
41724 arg4 = (int)(SWIG_As_int(obj3));
41725 if (SWIG_arg_fail(4)) SWIG_fail;
41726 }
41727 }
41728 {
41729 PyThreadState* __tstate = wxPyBeginAllowThreads();
41730 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41731
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj;
41744 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41745 size_t arg2 ;
41746 int arg3 = (int) 0 ;
41747 PyObject * obj0 = 0 ;
41748 PyObject * obj1 = 0 ;
41749 PyObject * obj2 = 0 ;
41750 char *kwnames[] = {
41751 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41752 };
41753
41754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41756 if (SWIG_arg_fail(1)) SWIG_fail;
41757 {
41758 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41759 if (SWIG_arg_fail(2)) SWIG_fail;
41760 }
41761 if (obj2) {
41762 {
41763 arg3 = (int)(SWIG_As_int(obj2));
41764 if (SWIG_arg_fail(3)) SWIG_fail;
41765 }
41766 }
41767 {
41768 PyThreadState* __tstate = wxPyBeginAllowThreads();
41769 (arg1)->AddGrowableRow(arg2,arg3);
41770
41771 wxPyEndAllowThreads(__tstate);
41772 if (PyErr_Occurred()) SWIG_fail;
41773 }
41774 Py_INCREF(Py_None); resultobj = Py_None;
41775 return resultobj;
41776 fail:
41777 return NULL;
41778 }
41779
41780
41781 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41782 PyObject *resultobj;
41783 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41784 size_t arg2 ;
41785 PyObject * obj0 = 0 ;
41786 PyObject * obj1 = 0 ;
41787 char *kwnames[] = {
41788 (char *) "self",(char *) "idx", NULL
41789 };
41790
41791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41793 if (SWIG_arg_fail(1)) SWIG_fail;
41794 {
41795 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41796 if (SWIG_arg_fail(2)) SWIG_fail;
41797 }
41798 {
41799 PyThreadState* __tstate = wxPyBeginAllowThreads();
41800 (arg1)->RemoveGrowableRow(arg2);
41801
41802 wxPyEndAllowThreads(__tstate);
41803 if (PyErr_Occurred()) SWIG_fail;
41804 }
41805 Py_INCREF(Py_None); resultobj = Py_None;
41806 return resultobj;
41807 fail:
41808 return NULL;
41809 }
41810
41811
41812 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41813 PyObject *resultobj;
41814 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41815 size_t arg2 ;
41816 int arg3 = (int) 0 ;
41817 PyObject * obj0 = 0 ;
41818 PyObject * obj1 = 0 ;
41819 PyObject * obj2 = 0 ;
41820 char *kwnames[] = {
41821 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41822 };
41823
41824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41826 if (SWIG_arg_fail(1)) SWIG_fail;
41827 {
41828 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41829 if (SWIG_arg_fail(2)) SWIG_fail;
41830 }
41831 if (obj2) {
41832 {
41833 arg3 = (int)(SWIG_As_int(obj2));
41834 if (SWIG_arg_fail(3)) SWIG_fail;
41835 }
41836 }
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 (arg1)->AddGrowableCol(arg2,arg3);
41840
41841 wxPyEndAllowThreads(__tstate);
41842 if (PyErr_Occurred()) SWIG_fail;
41843 }
41844 Py_INCREF(Py_None); resultobj = Py_None;
41845 return resultobj;
41846 fail:
41847 return NULL;
41848 }
41849
41850
41851 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41852 PyObject *resultobj;
41853 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41854 size_t arg2 ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 char *kwnames[] = {
41858 (char *) "self",(char *) "idx", NULL
41859 };
41860
41861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41863 if (SWIG_arg_fail(1)) SWIG_fail;
41864 {
41865 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41866 if (SWIG_arg_fail(2)) SWIG_fail;
41867 }
41868 {
41869 PyThreadState* __tstate = wxPyBeginAllowThreads();
41870 (arg1)->RemoveGrowableCol(arg2);
41871
41872 wxPyEndAllowThreads(__tstate);
41873 if (PyErr_Occurred()) SWIG_fail;
41874 }
41875 Py_INCREF(Py_None); resultobj = Py_None;
41876 return resultobj;
41877 fail:
41878 return NULL;
41879 }
41880
41881
41882 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41883 PyObject *resultobj;
41884 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41885 int arg2 ;
41886 PyObject * obj0 = 0 ;
41887 PyObject * obj1 = 0 ;
41888 char *kwnames[] = {
41889 (char *) "self",(char *) "direction", NULL
41890 };
41891
41892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41894 if (SWIG_arg_fail(1)) SWIG_fail;
41895 {
41896 arg2 = (int)(SWIG_As_int(obj1));
41897 if (SWIG_arg_fail(2)) SWIG_fail;
41898 }
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 (arg1)->SetFlexibleDirection(arg2);
41902
41903 wxPyEndAllowThreads(__tstate);
41904 if (PyErr_Occurred()) SWIG_fail;
41905 }
41906 Py_INCREF(Py_None); resultobj = Py_None;
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj;
41915 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41916 int result;
41917 PyObject * obj0 = 0 ;
41918 char *kwnames[] = {
41919 (char *) "self", NULL
41920 };
41921
41922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41924 if (SWIG_arg_fail(1)) SWIG_fail;
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 result = (int)(arg1)->GetFlexibleDirection();
41928
41929 wxPyEndAllowThreads(__tstate);
41930 if (PyErr_Occurred()) SWIG_fail;
41931 }
41932 {
41933 resultobj = SWIG_From_int((int)(result));
41934 }
41935 return resultobj;
41936 fail:
41937 return NULL;
41938 }
41939
41940
41941 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41942 PyObject *resultobj;
41943 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41944 wxFlexSizerGrowMode arg2 ;
41945 PyObject * obj0 = 0 ;
41946 PyObject * obj1 = 0 ;
41947 char *kwnames[] = {
41948 (char *) "self",(char *) "mode", NULL
41949 };
41950
41951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41953 if (SWIG_arg_fail(1)) SWIG_fail;
41954 {
41955 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41956 if (SWIG_arg_fail(2)) SWIG_fail;
41957 }
41958 {
41959 PyThreadState* __tstate = wxPyBeginAllowThreads();
41960 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41961
41962 wxPyEndAllowThreads(__tstate);
41963 if (PyErr_Occurred()) SWIG_fail;
41964 }
41965 Py_INCREF(Py_None); resultobj = Py_None;
41966 return resultobj;
41967 fail:
41968 return NULL;
41969 }
41970
41971
41972 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41973 PyObject *resultobj;
41974 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41975 wxFlexSizerGrowMode result;
41976 PyObject * obj0 = 0 ;
41977 char *kwnames[] = {
41978 (char *) "self", NULL
41979 };
41980
41981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41983 if (SWIG_arg_fail(1)) SWIG_fail;
41984 {
41985 PyThreadState* __tstate = wxPyBeginAllowThreads();
41986 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41987
41988 wxPyEndAllowThreads(__tstate);
41989 if (PyErr_Occurred()) SWIG_fail;
41990 }
41991 resultobj = SWIG_From_int((result));
41992 return resultobj;
41993 fail:
41994 return NULL;
41995 }
41996
41997
41998 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41999 PyObject *resultobj;
42000 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42001 wxArrayInt *result;
42002 PyObject * obj0 = 0 ;
42003 char *kwnames[] = {
42004 (char *) "self", NULL
42005 };
42006
42007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42009 if (SWIG_arg_fail(1)) SWIG_fail;
42010 {
42011 PyThreadState* __tstate = wxPyBeginAllowThreads();
42012 {
42013 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42014 result = (wxArrayInt *) &_result_ref;
42015 }
42016
42017 wxPyEndAllowThreads(__tstate);
42018 if (PyErr_Occurred()) SWIG_fail;
42019 }
42020 {
42021 resultobj = PyList_New(0);
42022 size_t idx;
42023 for (idx = 0; idx < result->GetCount(); idx += 1) {
42024 PyObject* val = PyInt_FromLong( result->Item(idx) );
42025 PyList_Append(resultobj, val);
42026 Py_DECREF(val);
42027 }
42028 }
42029 return resultobj;
42030 fail:
42031 return NULL;
42032 }
42033
42034
42035 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42036 PyObject *resultobj;
42037 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42038 wxArrayInt *result;
42039 PyObject * obj0 = 0 ;
42040 char *kwnames[] = {
42041 (char *) "self", NULL
42042 };
42043
42044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42046 if (SWIG_arg_fail(1)) SWIG_fail;
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 {
42050 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42051 result = (wxArrayInt *) &_result_ref;
42052 }
42053
42054 wxPyEndAllowThreads(__tstate);
42055 if (PyErr_Occurred()) SWIG_fail;
42056 }
42057 {
42058 resultobj = PyList_New(0);
42059 size_t idx;
42060 for (idx = 0; idx < result->GetCount(); idx += 1) {
42061 PyObject* val = PyInt_FromLong( result->Item(idx) );
42062 PyList_Append(resultobj, val);
42063 Py_DECREF(val);
42064 }
42065 }
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42073 PyObject *obj;
42074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42075 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42076 Py_INCREF(obj);
42077 return Py_BuildValue((char *)"");
42078 }
42079 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42080 PyObject *resultobj;
42081 wxStdDialogButtonSizer *result;
42082 char *kwnames[] = {
42083 NULL
42084 };
42085
42086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42087 {
42088 PyThreadState* __tstate = wxPyBeginAllowThreads();
42089 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42090
42091 wxPyEndAllowThreads(__tstate);
42092 if (PyErr_Occurred()) SWIG_fail;
42093 }
42094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42095 return resultobj;
42096 fail:
42097 return NULL;
42098 }
42099
42100
42101 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42102 PyObject *resultobj;
42103 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42104 wxButton *arg2 = (wxButton *) 0 ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 char *kwnames[] = {
42108 (char *) "self",(char *) "button", NULL
42109 };
42110
42111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42113 if (SWIG_arg_fail(1)) SWIG_fail;
42114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42115 if (SWIG_arg_fail(2)) SWIG_fail;
42116 {
42117 PyThreadState* __tstate = wxPyBeginAllowThreads();
42118 (arg1)->AddButton(arg2);
42119
42120 wxPyEndAllowThreads(__tstate);
42121 if (PyErr_Occurred()) SWIG_fail;
42122 }
42123 Py_INCREF(Py_None); resultobj = Py_None;
42124 return resultobj;
42125 fail:
42126 return NULL;
42127 }
42128
42129
42130 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42131 PyObject *resultobj;
42132 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42133 PyObject * obj0 = 0 ;
42134 char *kwnames[] = {
42135 (char *) "self", NULL
42136 };
42137
42138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42140 if (SWIG_arg_fail(1)) SWIG_fail;
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 (arg1)->Realize();
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 Py_INCREF(Py_None); resultobj = Py_None;
42149 return resultobj;
42150 fail:
42151 return NULL;
42152 }
42153
42154
42155 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42156 PyObject *resultobj;
42157 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42158 wxButton *arg2 = (wxButton *) 0 ;
42159 PyObject * obj0 = 0 ;
42160 PyObject * obj1 = 0 ;
42161 char *kwnames[] = {
42162 (char *) "self",(char *) "button", NULL
42163 };
42164
42165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42167 if (SWIG_arg_fail(1)) SWIG_fail;
42168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(2)) SWIG_fail;
42170 {
42171 PyThreadState* __tstate = wxPyBeginAllowThreads();
42172 (arg1)->SetAffirmativeButton(arg2);
42173
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 Py_INCREF(Py_None); resultobj = Py_None;
42178 return resultobj;
42179 fail:
42180 return NULL;
42181 }
42182
42183
42184 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42185 PyObject *resultobj;
42186 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42187 wxButton *arg2 = (wxButton *) 0 ;
42188 PyObject * obj0 = 0 ;
42189 PyObject * obj1 = 0 ;
42190 char *kwnames[] = {
42191 (char *) "self",(char *) "button", NULL
42192 };
42193
42194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42196 if (SWIG_arg_fail(1)) SWIG_fail;
42197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42198 if (SWIG_arg_fail(2)) SWIG_fail;
42199 {
42200 PyThreadState* __tstate = wxPyBeginAllowThreads();
42201 (arg1)->SetNegativeButton(arg2);
42202
42203 wxPyEndAllowThreads(__tstate);
42204 if (PyErr_Occurred()) SWIG_fail;
42205 }
42206 Py_INCREF(Py_None); resultobj = Py_None;
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj;
42215 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42216 wxButton *arg2 = (wxButton *) 0 ;
42217 PyObject * obj0 = 0 ;
42218 PyObject * obj1 = 0 ;
42219 char *kwnames[] = {
42220 (char *) "self",(char *) "button", NULL
42221 };
42222
42223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42225 if (SWIG_arg_fail(1)) SWIG_fail;
42226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42227 if (SWIG_arg_fail(2)) SWIG_fail;
42228 {
42229 PyThreadState* __tstate = wxPyBeginAllowThreads();
42230 (arg1)->SetCancelButton(arg2);
42231
42232 wxPyEndAllowThreads(__tstate);
42233 if (PyErr_Occurred()) SWIG_fail;
42234 }
42235 Py_INCREF(Py_None); resultobj = Py_None;
42236 return resultobj;
42237 fail:
42238 return NULL;
42239 }
42240
42241
42242 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42243 PyObject *resultobj;
42244 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42245 wxButton *result;
42246 PyObject * obj0 = 0 ;
42247 char *kwnames[] = {
42248 (char *) "self", NULL
42249 };
42250
42251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(1)) SWIG_fail;
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42257
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 {
42262 resultobj = wxPyMake_wxObject(result, 0);
42263 }
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42271 PyObject *resultobj;
42272 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42273 wxButton *result;
42274 PyObject * obj0 = 0 ;
42275 char *kwnames[] = {
42276 (char *) "self", NULL
42277 };
42278
42279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42281 if (SWIG_arg_fail(1)) SWIG_fail;
42282 {
42283 PyThreadState* __tstate = wxPyBeginAllowThreads();
42284 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42285
42286 wxPyEndAllowThreads(__tstate);
42287 if (PyErr_Occurred()) SWIG_fail;
42288 }
42289 {
42290 resultobj = wxPyMake_wxObject(result, 0);
42291 }
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42299 PyObject *resultobj;
42300 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42301 wxButton *result;
42302 PyObject * obj0 = 0 ;
42303 char *kwnames[] = {
42304 (char *) "self", NULL
42305 };
42306
42307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42309 if (SWIG_arg_fail(1)) SWIG_fail;
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42313
42314 wxPyEndAllowThreads(__tstate);
42315 if (PyErr_Occurred()) SWIG_fail;
42316 }
42317 {
42318 resultobj = wxPyMake_wxObject(result, 0);
42319 }
42320 return resultobj;
42321 fail:
42322 return NULL;
42323 }
42324
42325
42326 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42327 PyObject *resultobj;
42328 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42329 wxButton *result;
42330 PyObject * obj0 = 0 ;
42331 char *kwnames[] = {
42332 (char *) "self", NULL
42333 };
42334
42335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42337 if (SWIG_arg_fail(1)) SWIG_fail;
42338 {
42339 PyThreadState* __tstate = wxPyBeginAllowThreads();
42340 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42341
42342 wxPyEndAllowThreads(__tstate);
42343 if (PyErr_Occurred()) SWIG_fail;
42344 }
42345 {
42346 resultobj = wxPyMake_wxObject(result, 0);
42347 }
42348 return resultobj;
42349 fail:
42350 return NULL;
42351 }
42352
42353
42354 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42355 PyObject *resultobj;
42356 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42357 wxButton *result;
42358 PyObject * obj0 = 0 ;
42359 char *kwnames[] = {
42360 (char *) "self", NULL
42361 };
42362
42363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42365 if (SWIG_arg_fail(1)) SWIG_fail;
42366 {
42367 PyThreadState* __tstate = wxPyBeginAllowThreads();
42368 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42369
42370 wxPyEndAllowThreads(__tstate);
42371 if (PyErr_Occurred()) SWIG_fail;
42372 }
42373 {
42374 resultobj = wxPyMake_wxObject(result, 0);
42375 }
42376 return resultobj;
42377 fail:
42378 return NULL;
42379 }
42380
42381
42382 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42383 PyObject *obj;
42384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42385 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42386 Py_INCREF(obj);
42387 return Py_BuildValue((char *)"");
42388 }
42389 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj;
42391 int arg1 = (int) 0 ;
42392 int arg2 = (int) 0 ;
42393 wxGBPosition *result;
42394 PyObject * obj0 = 0 ;
42395 PyObject * obj1 = 0 ;
42396 char *kwnames[] = {
42397 (char *) "row",(char *) "col", NULL
42398 };
42399
42400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42401 if (obj0) {
42402 {
42403 arg1 = (int)(SWIG_As_int(obj0));
42404 if (SWIG_arg_fail(1)) SWIG_fail;
42405 }
42406 }
42407 if (obj1) {
42408 {
42409 arg2 = (int)(SWIG_As_int(obj1));
42410 if (SWIG_arg_fail(2)) SWIG_fail;
42411 }
42412 }
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42416
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj;
42429 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42430 int result;
42431 PyObject * obj0 = 0 ;
42432 char *kwnames[] = {
42433 (char *) "self", NULL
42434 };
42435
42436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42438 if (SWIG_arg_fail(1)) SWIG_fail;
42439 {
42440 PyThreadState* __tstate = wxPyBeginAllowThreads();
42441 result = (int)((wxGBPosition const *)arg1)->GetRow();
42442
42443 wxPyEndAllowThreads(__tstate);
42444 if (PyErr_Occurred()) SWIG_fail;
42445 }
42446 {
42447 resultobj = SWIG_From_int((int)(result));
42448 }
42449 return resultobj;
42450 fail:
42451 return NULL;
42452 }
42453
42454
42455 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42456 PyObject *resultobj;
42457 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42458 int result;
42459 PyObject * obj0 = 0 ;
42460 char *kwnames[] = {
42461 (char *) "self", NULL
42462 };
42463
42464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42466 if (SWIG_arg_fail(1)) SWIG_fail;
42467 {
42468 PyThreadState* __tstate = wxPyBeginAllowThreads();
42469 result = (int)((wxGBPosition const *)arg1)->GetCol();
42470
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 {
42475 resultobj = SWIG_From_int((int)(result));
42476 }
42477 return resultobj;
42478 fail:
42479 return NULL;
42480 }
42481
42482
42483 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42484 PyObject *resultobj;
42485 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42486 int arg2 ;
42487 PyObject * obj0 = 0 ;
42488 PyObject * obj1 = 0 ;
42489 char *kwnames[] = {
42490 (char *) "self",(char *) "row", NULL
42491 };
42492
42493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42495 if (SWIG_arg_fail(1)) SWIG_fail;
42496 {
42497 arg2 = (int)(SWIG_As_int(obj1));
42498 if (SWIG_arg_fail(2)) SWIG_fail;
42499 }
42500 {
42501 PyThreadState* __tstate = wxPyBeginAllowThreads();
42502 (arg1)->SetRow(arg2);
42503
42504 wxPyEndAllowThreads(__tstate);
42505 if (PyErr_Occurred()) SWIG_fail;
42506 }
42507 Py_INCREF(Py_None); resultobj = Py_None;
42508 return resultobj;
42509 fail:
42510 return NULL;
42511 }
42512
42513
42514 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42515 PyObject *resultobj;
42516 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42517 int arg2 ;
42518 PyObject * obj0 = 0 ;
42519 PyObject * obj1 = 0 ;
42520 char *kwnames[] = {
42521 (char *) "self",(char *) "col", NULL
42522 };
42523
42524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42526 if (SWIG_arg_fail(1)) SWIG_fail;
42527 {
42528 arg2 = (int)(SWIG_As_int(obj1));
42529 if (SWIG_arg_fail(2)) SWIG_fail;
42530 }
42531 {
42532 PyThreadState* __tstate = wxPyBeginAllowThreads();
42533 (arg1)->SetCol(arg2);
42534
42535 wxPyEndAllowThreads(__tstate);
42536 if (PyErr_Occurred()) SWIG_fail;
42537 }
42538 Py_INCREF(Py_None); resultobj = Py_None;
42539 return resultobj;
42540 fail:
42541 return NULL;
42542 }
42543
42544
42545 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42546 PyObject *resultobj;
42547 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42548 wxGBPosition *arg2 = 0 ;
42549 bool result;
42550 wxGBPosition temp2 ;
42551 PyObject * obj0 = 0 ;
42552 PyObject * obj1 = 0 ;
42553 char *kwnames[] = {
42554 (char *) "self",(char *) "other", NULL
42555 };
42556
42557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42559 if (SWIG_arg_fail(1)) SWIG_fail;
42560 {
42561 arg2 = &temp2;
42562 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42563 }
42564 {
42565 PyThreadState* __tstate = wxPyBeginAllowThreads();
42566 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42567
42568 wxPyEndAllowThreads(__tstate);
42569 if (PyErr_Occurred()) SWIG_fail;
42570 }
42571 {
42572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42573 }
42574 return resultobj;
42575 fail:
42576 return NULL;
42577 }
42578
42579
42580 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42581 PyObject *resultobj;
42582 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42583 wxGBPosition *arg2 = 0 ;
42584 bool result;
42585 wxGBPosition temp2 ;
42586 PyObject * obj0 = 0 ;
42587 PyObject * obj1 = 0 ;
42588 char *kwnames[] = {
42589 (char *) "self",(char *) "other", NULL
42590 };
42591
42592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42594 if (SWIG_arg_fail(1)) SWIG_fail;
42595 {
42596 arg2 = &temp2;
42597 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42598 }
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42602
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 {
42607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42608 }
42609 return resultobj;
42610 fail:
42611 return NULL;
42612 }
42613
42614
42615 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42616 PyObject *resultobj;
42617 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42618 int arg2 = (int) 0 ;
42619 int arg3 = (int) 0 ;
42620 PyObject * obj0 = 0 ;
42621 PyObject * obj1 = 0 ;
42622 PyObject * obj2 = 0 ;
42623 char *kwnames[] = {
42624 (char *) "self",(char *) "row",(char *) "col", NULL
42625 };
42626
42627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42629 if (SWIG_arg_fail(1)) SWIG_fail;
42630 if (obj1) {
42631 {
42632 arg2 = (int)(SWIG_As_int(obj1));
42633 if (SWIG_arg_fail(2)) SWIG_fail;
42634 }
42635 }
42636 if (obj2) {
42637 {
42638 arg3 = (int)(SWIG_As_int(obj2));
42639 if (SWIG_arg_fail(3)) SWIG_fail;
42640 }
42641 }
42642 {
42643 PyThreadState* __tstate = wxPyBeginAllowThreads();
42644 wxGBPosition_Set(arg1,arg2,arg3);
42645
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 Py_INCREF(Py_None); resultobj = Py_None;
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj;
42658 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42659 PyObject *result;
42660 PyObject * obj0 = 0 ;
42661 char *kwnames[] = {
42662 (char *) "self", NULL
42663 };
42664
42665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42667 if (SWIG_arg_fail(1)) SWIG_fail;
42668 {
42669 PyThreadState* __tstate = wxPyBeginAllowThreads();
42670 result = (PyObject *)wxGBPosition_Get(arg1);
42671
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 resultobj = result;
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42683 PyObject *obj;
42684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42685 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42686 Py_INCREF(obj);
42687 return Py_BuildValue((char *)"");
42688 }
42689 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42690 PyObject *resultobj;
42691 int arg1 = (int) 1 ;
42692 int arg2 = (int) 1 ;
42693 wxGBSpan *result;
42694 PyObject * obj0 = 0 ;
42695 PyObject * obj1 = 0 ;
42696 char *kwnames[] = {
42697 (char *) "rowspan",(char *) "colspan", NULL
42698 };
42699
42700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42701 if (obj0) {
42702 {
42703 arg1 = (int)(SWIG_As_int(obj0));
42704 if (SWIG_arg_fail(1)) SWIG_fail;
42705 }
42706 }
42707 if (obj1) {
42708 {
42709 arg2 = (int)(SWIG_As_int(obj1));
42710 if (SWIG_arg_fail(2)) SWIG_fail;
42711 }
42712 }
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42716
42717 wxPyEndAllowThreads(__tstate);
42718 if (PyErr_Occurred()) SWIG_fail;
42719 }
42720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42721 return resultobj;
42722 fail:
42723 return NULL;
42724 }
42725
42726
42727 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj;
42729 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42730 int result;
42731 PyObject * obj0 = 0 ;
42732 char *kwnames[] = {
42733 (char *) "self", NULL
42734 };
42735
42736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42738 if (SWIG_arg_fail(1)) SWIG_fail;
42739 {
42740 PyThreadState* __tstate = wxPyBeginAllowThreads();
42741 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42742
42743 wxPyEndAllowThreads(__tstate);
42744 if (PyErr_Occurred()) SWIG_fail;
42745 }
42746 {
42747 resultobj = SWIG_From_int((int)(result));
42748 }
42749 return resultobj;
42750 fail:
42751 return NULL;
42752 }
42753
42754
42755 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42756 PyObject *resultobj;
42757 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42758 int result;
42759 PyObject * obj0 = 0 ;
42760 char *kwnames[] = {
42761 (char *) "self", NULL
42762 };
42763
42764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42766 if (SWIG_arg_fail(1)) SWIG_fail;
42767 {
42768 PyThreadState* __tstate = wxPyBeginAllowThreads();
42769 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42770
42771 wxPyEndAllowThreads(__tstate);
42772 if (PyErr_Occurred()) SWIG_fail;
42773 }
42774 {
42775 resultobj = SWIG_From_int((int)(result));
42776 }
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42784 PyObject *resultobj;
42785 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42786 int arg2 ;
42787 PyObject * obj0 = 0 ;
42788 PyObject * obj1 = 0 ;
42789 char *kwnames[] = {
42790 (char *) "self",(char *) "rowspan", NULL
42791 };
42792
42793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42795 if (SWIG_arg_fail(1)) SWIG_fail;
42796 {
42797 arg2 = (int)(SWIG_As_int(obj1));
42798 if (SWIG_arg_fail(2)) SWIG_fail;
42799 }
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 (arg1)->SetRowspan(arg2);
42803
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 Py_INCREF(Py_None); resultobj = Py_None;
42808 return resultobj;
42809 fail:
42810 return NULL;
42811 }
42812
42813
42814 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42815 PyObject *resultobj;
42816 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42817 int arg2 ;
42818 PyObject * obj0 = 0 ;
42819 PyObject * obj1 = 0 ;
42820 char *kwnames[] = {
42821 (char *) "self",(char *) "colspan", NULL
42822 };
42823
42824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42826 if (SWIG_arg_fail(1)) SWIG_fail;
42827 {
42828 arg2 = (int)(SWIG_As_int(obj1));
42829 if (SWIG_arg_fail(2)) SWIG_fail;
42830 }
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 (arg1)->SetColspan(arg2);
42834
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 Py_INCREF(Py_None); resultobj = Py_None;
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj;
42847 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42848 wxGBSpan *arg2 = 0 ;
42849 bool result;
42850 wxGBSpan temp2 ;
42851 PyObject * obj0 = 0 ;
42852 PyObject * obj1 = 0 ;
42853 char *kwnames[] = {
42854 (char *) "self",(char *) "other", NULL
42855 };
42856
42857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(1)) SWIG_fail;
42860 {
42861 arg2 = &temp2;
42862 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42863 }
42864 {
42865 PyThreadState* __tstate = wxPyBeginAllowThreads();
42866 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42867
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 {
42872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42873 }
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj;
42882 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42883 wxGBSpan *arg2 = 0 ;
42884 bool result;
42885 wxGBSpan temp2 ;
42886 PyObject * obj0 = 0 ;
42887 PyObject * obj1 = 0 ;
42888 char *kwnames[] = {
42889 (char *) "self",(char *) "other", NULL
42890 };
42891
42892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42894 if (SWIG_arg_fail(1)) SWIG_fail;
42895 {
42896 arg2 = &temp2;
42897 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42898 }
42899 {
42900 PyThreadState* __tstate = wxPyBeginAllowThreads();
42901 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42902
42903 wxPyEndAllowThreads(__tstate);
42904 if (PyErr_Occurred()) SWIG_fail;
42905 }
42906 {
42907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42908 }
42909 return resultobj;
42910 fail:
42911 return NULL;
42912 }
42913
42914
42915 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42916 PyObject *resultobj;
42917 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42918 int arg2 = (int) 1 ;
42919 int arg3 = (int) 1 ;
42920 PyObject * obj0 = 0 ;
42921 PyObject * obj1 = 0 ;
42922 PyObject * obj2 = 0 ;
42923 char *kwnames[] = {
42924 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42925 };
42926
42927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42929 if (SWIG_arg_fail(1)) SWIG_fail;
42930 if (obj1) {
42931 {
42932 arg2 = (int)(SWIG_As_int(obj1));
42933 if (SWIG_arg_fail(2)) SWIG_fail;
42934 }
42935 }
42936 if (obj2) {
42937 {
42938 arg3 = (int)(SWIG_As_int(obj2));
42939 if (SWIG_arg_fail(3)) SWIG_fail;
42940 }
42941 }
42942 {
42943 PyThreadState* __tstate = wxPyBeginAllowThreads();
42944 wxGBSpan_Set(arg1,arg2,arg3);
42945
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 Py_INCREF(Py_None); resultobj = Py_None;
42950 return resultobj;
42951 fail:
42952 return NULL;
42953 }
42954
42955
42956 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42957 PyObject *resultobj;
42958 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42959 PyObject *result;
42960 PyObject * obj0 = 0 ;
42961 char *kwnames[] = {
42962 (char *) "self", NULL
42963 };
42964
42965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42967 if (SWIG_arg_fail(1)) SWIG_fail;
42968 {
42969 PyThreadState* __tstate = wxPyBeginAllowThreads();
42970 result = (PyObject *)wxGBSpan_Get(arg1);
42971
42972 wxPyEndAllowThreads(__tstate);
42973 if (PyErr_Occurred()) SWIG_fail;
42974 }
42975 resultobj = result;
42976 return resultobj;
42977 fail:
42978 return NULL;
42979 }
42980
42981
42982 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42983 PyObject *obj;
42984 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42985 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42986 Py_INCREF(obj);
42987 return Py_BuildValue((char *)"");
42988 }
42989 static int _wrap_DefaultSpan_set(PyObject *) {
42990 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42991 return 1;
42992 }
42993
42994
42995 static PyObject *_wrap_DefaultSpan_get(void) {
42996 PyObject *pyobj;
42997
42998 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42999 return pyobj;
43000 }
43001
43002
43003 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43004 PyObject *resultobj;
43005 wxGBSizerItem *result;
43006 char *kwnames[] = {
43007 NULL
43008 };
43009
43010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 result = (wxGBSizerItem *)new wxGBSizerItem();
43014
43015 wxPyEndAllowThreads(__tstate);
43016 if (PyErr_Occurred()) SWIG_fail;
43017 }
43018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43019 return resultobj;
43020 fail:
43021 return NULL;
43022 }
43023
43024
43025 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43026 PyObject *resultobj;
43027 wxWindow *arg1 = (wxWindow *) 0 ;
43028 wxGBPosition *arg2 = 0 ;
43029 wxGBSpan *arg3 = 0 ;
43030 int arg4 ;
43031 int arg5 ;
43032 PyObject *arg6 = (PyObject *) NULL ;
43033 wxGBSizerItem *result;
43034 wxGBPosition temp2 ;
43035 wxGBSpan temp3 ;
43036 PyObject * obj0 = 0 ;
43037 PyObject * obj1 = 0 ;
43038 PyObject * obj2 = 0 ;
43039 PyObject * obj3 = 0 ;
43040 PyObject * obj4 = 0 ;
43041 PyObject * obj5 = 0 ;
43042 char *kwnames[] = {
43043 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43044 };
43045
43046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43048 if (SWIG_arg_fail(1)) SWIG_fail;
43049 {
43050 arg2 = &temp2;
43051 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43052 }
43053 {
43054 arg3 = &temp3;
43055 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43056 }
43057 {
43058 arg4 = (int)(SWIG_As_int(obj3));
43059 if (SWIG_arg_fail(4)) SWIG_fail;
43060 }
43061 {
43062 arg5 = (int)(SWIG_As_int(obj4));
43063 if (SWIG_arg_fail(5)) SWIG_fail;
43064 }
43065 if (obj5) {
43066 arg6 = obj5;
43067 }
43068 {
43069 PyThreadState* __tstate = wxPyBeginAllowThreads();
43070 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43071
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43076 return resultobj;
43077 fail:
43078 return NULL;
43079 }
43080
43081
43082 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43083 PyObject *resultobj;
43084 wxSizer *arg1 = (wxSizer *) 0 ;
43085 wxGBPosition *arg2 = 0 ;
43086 wxGBSpan *arg3 = 0 ;
43087 int arg4 ;
43088 int arg5 ;
43089 PyObject *arg6 = (PyObject *) NULL ;
43090 wxGBSizerItem *result;
43091 wxGBPosition temp2 ;
43092 wxGBSpan temp3 ;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095 PyObject * obj2 = 0 ;
43096 PyObject * obj3 = 0 ;
43097 PyObject * obj4 = 0 ;
43098 PyObject * obj5 = 0 ;
43099 char *kwnames[] = {
43100 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43101 };
43102
43103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43105 if (SWIG_arg_fail(1)) SWIG_fail;
43106 {
43107 arg2 = &temp2;
43108 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43109 }
43110 {
43111 arg3 = &temp3;
43112 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43113 }
43114 {
43115 arg4 = (int)(SWIG_As_int(obj3));
43116 if (SWIG_arg_fail(4)) SWIG_fail;
43117 }
43118 {
43119 arg5 = (int)(SWIG_As_int(obj4));
43120 if (SWIG_arg_fail(5)) SWIG_fail;
43121 }
43122 if (obj5) {
43123 arg6 = obj5;
43124 }
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43128
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43133 return resultobj;
43134 fail:
43135 return NULL;
43136 }
43137
43138
43139 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43140 PyObject *resultobj;
43141 int arg1 ;
43142 int arg2 ;
43143 wxGBPosition *arg3 = 0 ;
43144 wxGBSpan *arg4 = 0 ;
43145 int arg5 ;
43146 int arg6 ;
43147 PyObject *arg7 = (PyObject *) NULL ;
43148 wxGBSizerItem *result;
43149 wxGBPosition temp3 ;
43150 wxGBSpan temp4 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 PyObject * obj2 = 0 ;
43154 PyObject * obj3 = 0 ;
43155 PyObject * obj4 = 0 ;
43156 PyObject * obj5 = 0 ;
43157 PyObject * obj6 = 0 ;
43158 char *kwnames[] = {
43159 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43160 };
43161
43162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43163 {
43164 arg1 = (int)(SWIG_As_int(obj0));
43165 if (SWIG_arg_fail(1)) SWIG_fail;
43166 }
43167 {
43168 arg2 = (int)(SWIG_As_int(obj1));
43169 if (SWIG_arg_fail(2)) SWIG_fail;
43170 }
43171 {
43172 arg3 = &temp3;
43173 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43174 }
43175 {
43176 arg4 = &temp4;
43177 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43178 }
43179 {
43180 arg5 = (int)(SWIG_As_int(obj4));
43181 if (SWIG_arg_fail(5)) SWIG_fail;
43182 }
43183 {
43184 arg6 = (int)(SWIG_As_int(obj5));
43185 if (SWIG_arg_fail(6)) SWIG_fail;
43186 }
43187 if (obj6) {
43188 arg7 = obj6;
43189 }
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43193
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43198 return resultobj;
43199 fail:
43200 return NULL;
43201 }
43202
43203
43204 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43205 PyObject *resultobj;
43206 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43207 wxGBPosition result;
43208 PyObject * obj0 = 0 ;
43209 char *kwnames[] = {
43210 (char *) "self", NULL
43211 };
43212
43213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43215 if (SWIG_arg_fail(1)) SWIG_fail;
43216 {
43217 PyThreadState* __tstate = wxPyBeginAllowThreads();
43218 result = ((wxGBSizerItem const *)arg1)->GetPos();
43219
43220 wxPyEndAllowThreads(__tstate);
43221 if (PyErr_Occurred()) SWIG_fail;
43222 }
43223 {
43224 wxGBPosition * resultptr;
43225 resultptr = new wxGBPosition((wxGBPosition &)(result));
43226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43227 }
43228 return resultobj;
43229 fail:
43230 return NULL;
43231 }
43232
43233
43234 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43235 PyObject *resultobj;
43236 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43237 wxGBSpan result;
43238 PyObject * obj0 = 0 ;
43239 char *kwnames[] = {
43240 (char *) "self", NULL
43241 };
43242
43243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43245 if (SWIG_arg_fail(1)) SWIG_fail;
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43249
43250 wxPyEndAllowThreads(__tstate);
43251 if (PyErr_Occurred()) SWIG_fail;
43252 }
43253 {
43254 wxGBSpan * resultptr;
43255 resultptr = new wxGBSpan((wxGBSpan &)(result));
43256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43257 }
43258 return resultobj;
43259 fail:
43260 return NULL;
43261 }
43262
43263
43264 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43265 PyObject *resultobj;
43266 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43267 wxGBPosition *arg2 = 0 ;
43268 bool result;
43269 wxGBPosition temp2 ;
43270 PyObject * obj0 = 0 ;
43271 PyObject * obj1 = 0 ;
43272 char *kwnames[] = {
43273 (char *) "self",(char *) "pos", NULL
43274 };
43275
43276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43278 if (SWIG_arg_fail(1)) SWIG_fail;
43279 {
43280 arg2 = &temp2;
43281 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43282 }
43283 {
43284 PyThreadState* __tstate = wxPyBeginAllowThreads();
43285 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43286
43287 wxPyEndAllowThreads(__tstate);
43288 if (PyErr_Occurred()) SWIG_fail;
43289 }
43290 {
43291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43292 }
43293 return resultobj;
43294 fail:
43295 return NULL;
43296 }
43297
43298
43299 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43300 PyObject *resultobj;
43301 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43302 wxGBSpan *arg2 = 0 ;
43303 bool result;
43304 wxGBSpan temp2 ;
43305 PyObject * obj0 = 0 ;
43306 PyObject * obj1 = 0 ;
43307 char *kwnames[] = {
43308 (char *) "self",(char *) "span", NULL
43309 };
43310
43311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 {
43315 arg2 = &temp2;
43316 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43317 }
43318 {
43319 PyThreadState* __tstate = wxPyBeginAllowThreads();
43320 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43321
43322 wxPyEndAllowThreads(__tstate);
43323 if (PyErr_Occurred()) SWIG_fail;
43324 }
43325 {
43326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43327 }
43328 return resultobj;
43329 fail:
43330 return NULL;
43331 }
43332
43333
43334 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43335 PyObject *resultobj;
43336 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43337 wxGBSizerItem *arg2 = 0 ;
43338 bool result;
43339 PyObject * obj0 = 0 ;
43340 PyObject * obj1 = 0 ;
43341 char *kwnames[] = {
43342 (char *) "self",(char *) "other", NULL
43343 };
43344
43345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43347 if (SWIG_arg_fail(1)) SWIG_fail;
43348 {
43349 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43350 if (SWIG_arg_fail(2)) SWIG_fail;
43351 if (arg2 == NULL) {
43352 SWIG_null_ref("wxGBSizerItem");
43353 }
43354 if (SWIG_arg_fail(2)) SWIG_fail;
43355 }
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43359
43360 wxPyEndAllowThreads(__tstate);
43361 if (PyErr_Occurred()) SWIG_fail;
43362 }
43363 {
43364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43365 }
43366 return resultobj;
43367 fail:
43368 return NULL;
43369 }
43370
43371
43372 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43373 PyObject *resultobj;
43374 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43375 wxGBPosition *arg2 = 0 ;
43376 wxGBSpan *arg3 = 0 ;
43377 bool result;
43378 wxGBPosition temp2 ;
43379 wxGBSpan temp3 ;
43380 PyObject * obj0 = 0 ;
43381 PyObject * obj1 = 0 ;
43382 PyObject * obj2 = 0 ;
43383 char *kwnames[] = {
43384 (char *) "self",(char *) "pos",(char *) "span", NULL
43385 };
43386
43387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43389 if (SWIG_arg_fail(1)) SWIG_fail;
43390 {
43391 arg2 = &temp2;
43392 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43393 }
43394 {
43395 arg3 = &temp3;
43396 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43397 }
43398 {
43399 PyThreadState* __tstate = wxPyBeginAllowThreads();
43400 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43401
43402 wxPyEndAllowThreads(__tstate);
43403 if (PyErr_Occurred()) SWIG_fail;
43404 }
43405 {
43406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43407 }
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43415 PyObject *resultobj;
43416 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43417 wxGBPosition result;
43418 PyObject * obj0 = 0 ;
43419 char *kwnames[] = {
43420 (char *) "self", NULL
43421 };
43422
43423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43425 if (SWIG_arg_fail(1)) SWIG_fail;
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 result = wxGBSizerItem_GetEndPos(arg1);
43429
43430 wxPyEndAllowThreads(__tstate);
43431 if (PyErr_Occurred()) SWIG_fail;
43432 }
43433 {
43434 wxGBPosition * resultptr;
43435 resultptr = new wxGBPosition((wxGBPosition &)(result));
43436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43437 }
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43445 PyObject *resultobj;
43446 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43447 wxGridBagSizer *result;
43448 PyObject * obj0 = 0 ;
43449 char *kwnames[] = {
43450 (char *) "self", NULL
43451 };
43452
43453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43455 if (SWIG_arg_fail(1)) SWIG_fail;
43456 {
43457 PyThreadState* __tstate = wxPyBeginAllowThreads();
43458 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43459
43460 wxPyEndAllowThreads(__tstate);
43461 if (PyErr_Occurred()) SWIG_fail;
43462 }
43463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43464 return resultobj;
43465 fail:
43466 return NULL;
43467 }
43468
43469
43470 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43471 PyObject *resultobj;
43472 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43473 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43474 PyObject * obj0 = 0 ;
43475 PyObject * obj1 = 0 ;
43476 char *kwnames[] = {
43477 (char *) "self",(char *) "sizer", NULL
43478 };
43479
43480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43482 if (SWIG_arg_fail(1)) SWIG_fail;
43483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43484 if (SWIG_arg_fail(2)) SWIG_fail;
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 (arg1)->SetGBSizer(arg2);
43488
43489 wxPyEndAllowThreads(__tstate);
43490 if (PyErr_Occurred()) SWIG_fail;
43491 }
43492 Py_INCREF(Py_None); resultobj = Py_None;
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43500 PyObject *obj;
43501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43502 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43503 Py_INCREF(obj);
43504 return Py_BuildValue((char *)"");
43505 }
43506 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43507 PyObject *resultobj;
43508 int arg1 = (int) 0 ;
43509 int arg2 = (int) 0 ;
43510 wxGridBagSizer *result;
43511 PyObject * obj0 = 0 ;
43512 PyObject * obj1 = 0 ;
43513 char *kwnames[] = {
43514 (char *) "vgap",(char *) "hgap", NULL
43515 };
43516
43517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43518 if (obj0) {
43519 {
43520 arg1 = (int)(SWIG_As_int(obj0));
43521 if (SWIG_arg_fail(1)) SWIG_fail;
43522 }
43523 }
43524 if (obj1) {
43525 {
43526 arg2 = (int)(SWIG_As_int(obj1));
43527 if (SWIG_arg_fail(2)) SWIG_fail;
43528 }
43529 }
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43533
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43538 return resultobj;
43539 fail:
43540 return NULL;
43541 }
43542
43543
43544 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43545 PyObject *resultobj;
43546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43547 PyObject *arg2 = (PyObject *) 0 ;
43548 wxGBPosition *arg3 = 0 ;
43549 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43550 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43551 int arg5 = (int) 0 ;
43552 int arg6 = (int) 0 ;
43553 PyObject *arg7 = (PyObject *) NULL ;
43554 wxGBSizerItem *result;
43555 wxGBPosition temp3 ;
43556 wxGBSpan temp4 ;
43557 PyObject * obj0 = 0 ;
43558 PyObject * obj1 = 0 ;
43559 PyObject * obj2 = 0 ;
43560 PyObject * obj3 = 0 ;
43561 PyObject * obj4 = 0 ;
43562 PyObject * obj5 = 0 ;
43563 PyObject * obj6 = 0 ;
43564 char *kwnames[] = {
43565 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43566 };
43567
43568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43570 if (SWIG_arg_fail(1)) SWIG_fail;
43571 arg2 = obj1;
43572 {
43573 arg3 = &temp3;
43574 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43575 }
43576 if (obj3) {
43577 {
43578 arg4 = &temp4;
43579 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43580 }
43581 }
43582 if (obj4) {
43583 {
43584 arg5 = (int)(SWIG_As_int(obj4));
43585 if (SWIG_arg_fail(5)) SWIG_fail;
43586 }
43587 }
43588 if (obj5) {
43589 {
43590 arg6 = (int)(SWIG_As_int(obj5));
43591 if (SWIG_arg_fail(6)) SWIG_fail;
43592 }
43593 }
43594 if (obj6) {
43595 arg7 = obj6;
43596 }
43597 {
43598 PyThreadState* __tstate = wxPyBeginAllowThreads();
43599 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43600
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43605 return resultobj;
43606 fail:
43607 return NULL;
43608 }
43609
43610
43611 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43612 PyObject *resultobj;
43613 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43614 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43615 wxGBSizerItem *result;
43616 PyObject * obj0 = 0 ;
43617 PyObject * obj1 = 0 ;
43618 char *kwnames[] = {
43619 (char *) "self",(char *) "item", NULL
43620 };
43621
43622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43624 if (SWIG_arg_fail(1)) SWIG_fail;
43625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43626 if (SWIG_arg_fail(2)) SWIG_fail;
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43630
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43635 return resultobj;
43636 fail:
43637 return NULL;
43638 }
43639
43640
43641 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43642 PyObject *resultobj;
43643 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43644 int arg2 ;
43645 int arg3 ;
43646 wxSize result;
43647 PyObject * obj0 = 0 ;
43648 PyObject * obj1 = 0 ;
43649 PyObject * obj2 = 0 ;
43650 char *kwnames[] = {
43651 (char *) "self",(char *) "row",(char *) "col", NULL
43652 };
43653
43654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43656 if (SWIG_arg_fail(1)) SWIG_fail;
43657 {
43658 arg2 = (int)(SWIG_As_int(obj1));
43659 if (SWIG_arg_fail(2)) SWIG_fail;
43660 }
43661 {
43662 arg3 = (int)(SWIG_As_int(obj2));
43663 if (SWIG_arg_fail(3)) SWIG_fail;
43664 }
43665 {
43666 PyThreadState* __tstate = wxPyBeginAllowThreads();
43667 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43668
43669 wxPyEndAllowThreads(__tstate);
43670 if (PyErr_Occurred()) SWIG_fail;
43671 }
43672 {
43673 wxSize * resultptr;
43674 resultptr = new wxSize((wxSize &)(result));
43675 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43676 }
43677 return resultobj;
43678 fail:
43679 return NULL;
43680 }
43681
43682
43683 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43684 PyObject *resultobj;
43685 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43686 wxSize result;
43687 PyObject * obj0 = 0 ;
43688 char *kwnames[] = {
43689 (char *) "self", NULL
43690 };
43691
43692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43694 if (SWIG_arg_fail(1)) SWIG_fail;
43695 {
43696 PyThreadState* __tstate = wxPyBeginAllowThreads();
43697 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43698
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 {
43703 wxSize * resultptr;
43704 resultptr = new wxSize((wxSize &)(result));
43705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43706 }
43707 return resultobj;
43708 fail:
43709 return NULL;
43710 }
43711
43712
43713 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43714 PyObject *resultobj;
43715 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43716 wxSize *arg2 = 0 ;
43717 wxSize temp2 ;
43718 PyObject * obj0 = 0 ;
43719 PyObject * obj1 = 0 ;
43720 char *kwnames[] = {
43721 (char *) "self",(char *) "sz", NULL
43722 };
43723
43724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43726 if (SWIG_arg_fail(1)) SWIG_fail;
43727 {
43728 arg2 = &temp2;
43729 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43730 }
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43734
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 Py_INCREF(Py_None); resultobj = Py_None;
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43746 PyObject *resultobj;
43747 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43748 wxWindow *arg2 = (wxWindow *) 0 ;
43749 wxGBPosition result;
43750 PyObject * obj0 = 0 ;
43751 PyObject * obj1 = 0 ;
43752
43753 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43755 if (SWIG_arg_fail(1)) SWIG_fail;
43756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43757 if (SWIG_arg_fail(2)) SWIG_fail;
43758 {
43759 PyThreadState* __tstate = wxPyBeginAllowThreads();
43760 result = (arg1)->GetItemPosition(arg2);
43761
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 {
43766 wxGBPosition * resultptr;
43767 resultptr = new wxGBPosition((wxGBPosition &)(result));
43768 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43769 }
43770 return resultobj;
43771 fail:
43772 return NULL;
43773 }
43774
43775
43776 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43777 PyObject *resultobj;
43778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43779 wxSizer *arg2 = (wxSizer *) 0 ;
43780 wxGBPosition result;
43781 PyObject * obj0 = 0 ;
43782 PyObject * obj1 = 0 ;
43783
43784 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43786 if (SWIG_arg_fail(1)) SWIG_fail;
43787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43788 if (SWIG_arg_fail(2)) SWIG_fail;
43789 {
43790 PyThreadState* __tstate = wxPyBeginAllowThreads();
43791 result = (arg1)->GetItemPosition(arg2);
43792
43793 wxPyEndAllowThreads(__tstate);
43794 if (PyErr_Occurred()) SWIG_fail;
43795 }
43796 {
43797 wxGBPosition * resultptr;
43798 resultptr = new wxGBPosition((wxGBPosition &)(result));
43799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43800 }
43801 return resultobj;
43802 fail:
43803 return NULL;
43804 }
43805
43806
43807 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43808 PyObject *resultobj;
43809 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43810 size_t arg2 ;
43811 wxGBPosition result;
43812 PyObject * obj0 = 0 ;
43813 PyObject * obj1 = 0 ;
43814
43815 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43817 if (SWIG_arg_fail(1)) SWIG_fail;
43818 {
43819 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43820 if (SWIG_arg_fail(2)) SWIG_fail;
43821 }
43822 {
43823 PyThreadState* __tstate = wxPyBeginAllowThreads();
43824 result = (arg1)->GetItemPosition(arg2);
43825
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 {
43830 wxGBPosition * resultptr;
43831 resultptr = new wxGBPosition((wxGBPosition &)(result));
43832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43833 }
43834 return resultobj;
43835 fail:
43836 return NULL;
43837 }
43838
43839
43840 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43841 int argc;
43842 PyObject *argv[3];
43843 int ii;
43844
43845 argc = PyObject_Length(args);
43846 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43847 argv[ii] = PyTuple_GetItem(args,ii);
43848 }
43849 if (argc == 2) {
43850 int _v;
43851 {
43852 void *ptr;
43853 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43854 _v = 0;
43855 PyErr_Clear();
43856 } else {
43857 _v = 1;
43858 }
43859 }
43860 if (_v) {
43861 {
43862 void *ptr;
43863 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43864 _v = 0;
43865 PyErr_Clear();
43866 } else {
43867 _v = 1;
43868 }
43869 }
43870 if (_v) {
43871 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43872 }
43873 }
43874 }
43875 if (argc == 2) {
43876 int _v;
43877 {
43878 void *ptr;
43879 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43880 _v = 0;
43881 PyErr_Clear();
43882 } else {
43883 _v = 1;
43884 }
43885 }
43886 if (_v) {
43887 {
43888 void *ptr;
43889 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43890 _v = 0;
43891 PyErr_Clear();
43892 } else {
43893 _v = 1;
43894 }
43895 }
43896 if (_v) {
43897 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43898 }
43899 }
43900 }
43901 if (argc == 2) {
43902 int _v;
43903 {
43904 void *ptr;
43905 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43906 _v = 0;
43907 PyErr_Clear();
43908 } else {
43909 _v = 1;
43910 }
43911 }
43912 if (_v) {
43913 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43914 if (_v) {
43915 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43916 }
43917 }
43918 }
43919
43920 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43921 return NULL;
43922 }
43923
43924
43925 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43926 PyObject *resultobj;
43927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43928 wxWindow *arg2 = (wxWindow *) 0 ;
43929 wxGBPosition *arg3 = 0 ;
43930 bool result;
43931 wxGBPosition temp3 ;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934 PyObject * obj2 = 0 ;
43935
43936 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43938 if (SWIG_arg_fail(1)) SWIG_fail;
43939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43940 if (SWIG_arg_fail(2)) SWIG_fail;
43941 {
43942 arg3 = &temp3;
43943 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43944 }
43945 {
43946 PyThreadState* __tstate = wxPyBeginAllowThreads();
43947 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43948
43949 wxPyEndAllowThreads(__tstate);
43950 if (PyErr_Occurred()) SWIG_fail;
43951 }
43952 {
43953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43954 }
43955 return resultobj;
43956 fail:
43957 return NULL;
43958 }
43959
43960
43961 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43962 PyObject *resultobj;
43963 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43964 wxSizer *arg2 = (wxSizer *) 0 ;
43965 wxGBPosition *arg3 = 0 ;
43966 bool result;
43967 wxGBPosition temp3 ;
43968 PyObject * obj0 = 0 ;
43969 PyObject * obj1 = 0 ;
43970 PyObject * obj2 = 0 ;
43971
43972 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43974 if (SWIG_arg_fail(1)) SWIG_fail;
43975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43976 if (SWIG_arg_fail(2)) SWIG_fail;
43977 {
43978 arg3 = &temp3;
43979 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43980 }
43981 {
43982 PyThreadState* __tstate = wxPyBeginAllowThreads();
43983 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43984
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 {
43989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43990 }
43991 return resultobj;
43992 fail:
43993 return NULL;
43994 }
43995
43996
43997 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43998 PyObject *resultobj;
43999 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44000 size_t arg2 ;
44001 wxGBPosition *arg3 = 0 ;
44002 bool result;
44003 wxGBPosition temp3 ;
44004 PyObject * obj0 = 0 ;
44005 PyObject * obj1 = 0 ;
44006 PyObject * obj2 = 0 ;
44007
44008 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44010 if (SWIG_arg_fail(1)) SWIG_fail;
44011 {
44012 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44013 if (SWIG_arg_fail(2)) SWIG_fail;
44014 }
44015 {
44016 arg3 = &temp3;
44017 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44018 }
44019 {
44020 PyThreadState* __tstate = wxPyBeginAllowThreads();
44021 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44022
44023 wxPyEndAllowThreads(__tstate);
44024 if (PyErr_Occurred()) SWIG_fail;
44025 }
44026 {
44027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44028 }
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44036 int argc;
44037 PyObject *argv[4];
44038 int ii;
44039
44040 argc = PyObject_Length(args);
44041 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44042 argv[ii] = PyTuple_GetItem(args,ii);
44043 }
44044 if (argc == 3) {
44045 int _v;
44046 {
44047 void *ptr;
44048 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44049 _v = 0;
44050 PyErr_Clear();
44051 } else {
44052 _v = 1;
44053 }
44054 }
44055 if (_v) {
44056 {
44057 void *ptr;
44058 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44059 _v = 0;
44060 PyErr_Clear();
44061 } else {
44062 _v = 1;
44063 }
44064 }
44065 if (_v) {
44066 {
44067 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44068 }
44069 if (_v) {
44070 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44071 }
44072 }
44073 }
44074 }
44075 if (argc == 3) {
44076 int _v;
44077 {
44078 void *ptr;
44079 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44080 _v = 0;
44081 PyErr_Clear();
44082 } else {
44083 _v = 1;
44084 }
44085 }
44086 if (_v) {
44087 {
44088 void *ptr;
44089 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44090 _v = 0;
44091 PyErr_Clear();
44092 } else {
44093 _v = 1;
44094 }
44095 }
44096 if (_v) {
44097 {
44098 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44099 }
44100 if (_v) {
44101 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44102 }
44103 }
44104 }
44105 }
44106 if (argc == 3) {
44107 int _v;
44108 {
44109 void *ptr;
44110 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44111 _v = 0;
44112 PyErr_Clear();
44113 } else {
44114 _v = 1;
44115 }
44116 }
44117 if (_v) {
44118 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44119 if (_v) {
44120 {
44121 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44122 }
44123 if (_v) {
44124 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44125 }
44126 }
44127 }
44128 }
44129
44130 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44131 return NULL;
44132 }
44133
44134
44135 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44136 PyObject *resultobj;
44137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44138 wxWindow *arg2 = (wxWindow *) 0 ;
44139 wxGBSpan result;
44140 PyObject * obj0 = 0 ;
44141 PyObject * obj1 = 0 ;
44142
44143 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44145 if (SWIG_arg_fail(1)) SWIG_fail;
44146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44147 if (SWIG_arg_fail(2)) SWIG_fail;
44148 {
44149 PyThreadState* __tstate = wxPyBeginAllowThreads();
44150 result = (arg1)->GetItemSpan(arg2);
44151
44152 wxPyEndAllowThreads(__tstate);
44153 if (PyErr_Occurred()) SWIG_fail;
44154 }
44155 {
44156 wxGBSpan * resultptr;
44157 resultptr = new wxGBSpan((wxGBSpan &)(result));
44158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44159 }
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44167 PyObject *resultobj;
44168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44169 wxSizer *arg2 = (wxSizer *) 0 ;
44170 wxGBSpan result;
44171 PyObject * obj0 = 0 ;
44172 PyObject * obj1 = 0 ;
44173
44174 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44176 if (SWIG_arg_fail(1)) SWIG_fail;
44177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44178 if (SWIG_arg_fail(2)) SWIG_fail;
44179 {
44180 PyThreadState* __tstate = wxPyBeginAllowThreads();
44181 result = (arg1)->GetItemSpan(arg2);
44182
44183 wxPyEndAllowThreads(__tstate);
44184 if (PyErr_Occurred()) SWIG_fail;
44185 }
44186 {
44187 wxGBSpan * resultptr;
44188 resultptr = new wxGBSpan((wxGBSpan &)(result));
44189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44190 }
44191 return resultobj;
44192 fail:
44193 return NULL;
44194 }
44195
44196
44197 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44198 PyObject *resultobj;
44199 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44200 size_t arg2 ;
44201 wxGBSpan result;
44202 PyObject * obj0 = 0 ;
44203 PyObject * obj1 = 0 ;
44204
44205 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44207 if (SWIG_arg_fail(1)) SWIG_fail;
44208 {
44209 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44210 if (SWIG_arg_fail(2)) SWIG_fail;
44211 }
44212 {
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 result = (arg1)->GetItemSpan(arg2);
44215
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 {
44220 wxGBSpan * resultptr;
44221 resultptr = new wxGBSpan((wxGBSpan &)(result));
44222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44223 }
44224 return resultobj;
44225 fail:
44226 return NULL;
44227 }
44228
44229
44230 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44231 int argc;
44232 PyObject *argv[3];
44233 int ii;
44234
44235 argc = PyObject_Length(args);
44236 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44237 argv[ii] = PyTuple_GetItem(args,ii);
44238 }
44239 if (argc == 2) {
44240 int _v;
44241 {
44242 void *ptr;
44243 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44244 _v = 0;
44245 PyErr_Clear();
44246 } else {
44247 _v = 1;
44248 }
44249 }
44250 if (_v) {
44251 {
44252 void *ptr;
44253 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44254 _v = 0;
44255 PyErr_Clear();
44256 } else {
44257 _v = 1;
44258 }
44259 }
44260 if (_v) {
44261 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44262 }
44263 }
44264 }
44265 if (argc == 2) {
44266 int _v;
44267 {
44268 void *ptr;
44269 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44270 _v = 0;
44271 PyErr_Clear();
44272 } else {
44273 _v = 1;
44274 }
44275 }
44276 if (_v) {
44277 {
44278 void *ptr;
44279 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44280 _v = 0;
44281 PyErr_Clear();
44282 } else {
44283 _v = 1;
44284 }
44285 }
44286 if (_v) {
44287 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44288 }
44289 }
44290 }
44291 if (argc == 2) {
44292 int _v;
44293 {
44294 void *ptr;
44295 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44296 _v = 0;
44297 PyErr_Clear();
44298 } else {
44299 _v = 1;
44300 }
44301 }
44302 if (_v) {
44303 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44304 if (_v) {
44305 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44306 }
44307 }
44308 }
44309
44310 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44311 return NULL;
44312 }
44313
44314
44315 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44316 PyObject *resultobj;
44317 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44318 wxWindow *arg2 = (wxWindow *) 0 ;
44319 wxGBSpan *arg3 = 0 ;
44320 bool result;
44321 wxGBSpan temp3 ;
44322 PyObject * obj0 = 0 ;
44323 PyObject * obj1 = 0 ;
44324 PyObject * obj2 = 0 ;
44325
44326 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44328 if (SWIG_arg_fail(1)) SWIG_fail;
44329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44330 if (SWIG_arg_fail(2)) SWIG_fail;
44331 {
44332 arg3 = &temp3;
44333 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44334 }
44335 {
44336 PyThreadState* __tstate = wxPyBeginAllowThreads();
44337 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44338
44339 wxPyEndAllowThreads(__tstate);
44340 if (PyErr_Occurred()) SWIG_fail;
44341 }
44342 {
44343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44344 }
44345 return resultobj;
44346 fail:
44347 return NULL;
44348 }
44349
44350
44351 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44352 PyObject *resultobj;
44353 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44354 wxSizer *arg2 = (wxSizer *) 0 ;
44355 wxGBSpan *arg3 = 0 ;
44356 bool result;
44357 wxGBSpan temp3 ;
44358 PyObject * obj0 = 0 ;
44359 PyObject * obj1 = 0 ;
44360 PyObject * obj2 = 0 ;
44361
44362 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44364 if (SWIG_arg_fail(1)) SWIG_fail;
44365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44366 if (SWIG_arg_fail(2)) SWIG_fail;
44367 {
44368 arg3 = &temp3;
44369 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44370 }
44371 {
44372 PyThreadState* __tstate = wxPyBeginAllowThreads();
44373 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44374
44375 wxPyEndAllowThreads(__tstate);
44376 if (PyErr_Occurred()) SWIG_fail;
44377 }
44378 {
44379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44380 }
44381 return resultobj;
44382 fail:
44383 return NULL;
44384 }
44385
44386
44387 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44388 PyObject *resultobj;
44389 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44390 size_t arg2 ;
44391 wxGBSpan *arg3 = 0 ;
44392 bool result;
44393 wxGBSpan temp3 ;
44394 PyObject * obj0 = 0 ;
44395 PyObject * obj1 = 0 ;
44396 PyObject * obj2 = 0 ;
44397
44398 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44400 if (SWIG_arg_fail(1)) SWIG_fail;
44401 {
44402 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44403 if (SWIG_arg_fail(2)) SWIG_fail;
44404 }
44405 {
44406 arg3 = &temp3;
44407 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44408 }
44409 {
44410 PyThreadState* __tstate = wxPyBeginAllowThreads();
44411 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44412
44413 wxPyEndAllowThreads(__tstate);
44414 if (PyErr_Occurred()) SWIG_fail;
44415 }
44416 {
44417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44418 }
44419 return resultobj;
44420 fail:
44421 return NULL;
44422 }
44423
44424
44425 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44426 int argc;
44427 PyObject *argv[4];
44428 int ii;
44429
44430 argc = PyObject_Length(args);
44431 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44432 argv[ii] = PyTuple_GetItem(args,ii);
44433 }
44434 if (argc == 3) {
44435 int _v;
44436 {
44437 void *ptr;
44438 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44439 _v = 0;
44440 PyErr_Clear();
44441 } else {
44442 _v = 1;
44443 }
44444 }
44445 if (_v) {
44446 {
44447 void *ptr;
44448 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44449 _v = 0;
44450 PyErr_Clear();
44451 } else {
44452 _v = 1;
44453 }
44454 }
44455 if (_v) {
44456 {
44457 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44458 }
44459 if (_v) {
44460 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44461 }
44462 }
44463 }
44464 }
44465 if (argc == 3) {
44466 int _v;
44467 {
44468 void *ptr;
44469 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44470 _v = 0;
44471 PyErr_Clear();
44472 } else {
44473 _v = 1;
44474 }
44475 }
44476 if (_v) {
44477 {
44478 void *ptr;
44479 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44480 _v = 0;
44481 PyErr_Clear();
44482 } else {
44483 _v = 1;
44484 }
44485 }
44486 if (_v) {
44487 {
44488 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44489 }
44490 if (_v) {
44491 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44492 }
44493 }
44494 }
44495 }
44496 if (argc == 3) {
44497 int _v;
44498 {
44499 void *ptr;
44500 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44501 _v = 0;
44502 PyErr_Clear();
44503 } else {
44504 _v = 1;
44505 }
44506 }
44507 if (_v) {
44508 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44509 if (_v) {
44510 {
44511 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44512 }
44513 if (_v) {
44514 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44515 }
44516 }
44517 }
44518 }
44519
44520 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44521 return NULL;
44522 }
44523
44524
44525 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44526 PyObject *resultobj;
44527 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44528 wxWindow *arg2 = (wxWindow *) 0 ;
44529 wxGBSizerItem *result;
44530 PyObject * obj0 = 0 ;
44531 PyObject * obj1 = 0 ;
44532
44533 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44535 if (SWIG_arg_fail(1)) SWIG_fail;
44536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44537 if (SWIG_arg_fail(2)) SWIG_fail;
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44541
44542 wxPyEndAllowThreads(__tstate);
44543 if (PyErr_Occurred()) SWIG_fail;
44544 }
44545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44546 return resultobj;
44547 fail:
44548 return NULL;
44549 }
44550
44551
44552 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44553 PyObject *resultobj;
44554 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44555 wxSizer *arg2 = (wxSizer *) 0 ;
44556 wxGBSizerItem *result;
44557 PyObject * obj0 = 0 ;
44558 PyObject * obj1 = 0 ;
44559
44560 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44562 if (SWIG_arg_fail(1)) SWIG_fail;
44563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44564 if (SWIG_arg_fail(2)) SWIG_fail;
44565 {
44566 PyThreadState* __tstate = wxPyBeginAllowThreads();
44567 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44568
44569 wxPyEndAllowThreads(__tstate);
44570 if (PyErr_Occurred()) SWIG_fail;
44571 }
44572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44580 int argc;
44581 PyObject *argv[3];
44582 int ii;
44583
44584 argc = PyObject_Length(args);
44585 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44586 argv[ii] = PyTuple_GetItem(args,ii);
44587 }
44588 if (argc == 2) {
44589 int _v;
44590 {
44591 void *ptr;
44592 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44593 _v = 0;
44594 PyErr_Clear();
44595 } else {
44596 _v = 1;
44597 }
44598 }
44599 if (_v) {
44600 {
44601 void *ptr;
44602 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44603 _v = 0;
44604 PyErr_Clear();
44605 } else {
44606 _v = 1;
44607 }
44608 }
44609 if (_v) {
44610 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44611 }
44612 }
44613 }
44614 if (argc == 2) {
44615 int _v;
44616 {
44617 void *ptr;
44618 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44619 _v = 0;
44620 PyErr_Clear();
44621 } else {
44622 _v = 1;
44623 }
44624 }
44625 if (_v) {
44626 {
44627 void *ptr;
44628 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44629 _v = 0;
44630 PyErr_Clear();
44631 } else {
44632 _v = 1;
44633 }
44634 }
44635 if (_v) {
44636 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44637 }
44638 }
44639 }
44640
44641 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44642 return NULL;
44643 }
44644
44645
44646 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44647 PyObject *resultobj;
44648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44649 wxGBPosition *arg2 = 0 ;
44650 wxGBSizerItem *result;
44651 wxGBPosition temp2 ;
44652 PyObject * obj0 = 0 ;
44653 PyObject * obj1 = 0 ;
44654 char *kwnames[] = {
44655 (char *) "self",(char *) "pos", NULL
44656 };
44657
44658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44660 if (SWIG_arg_fail(1)) SWIG_fail;
44661 {
44662 arg2 = &temp2;
44663 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44664 }
44665 {
44666 PyThreadState* __tstate = wxPyBeginAllowThreads();
44667 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44668
44669 wxPyEndAllowThreads(__tstate);
44670 if (PyErr_Occurred()) SWIG_fail;
44671 }
44672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44673 return resultobj;
44674 fail:
44675 return NULL;
44676 }
44677
44678
44679 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44680 PyObject *resultobj;
44681 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44682 wxPoint *arg2 = 0 ;
44683 wxGBSizerItem *result;
44684 wxPoint temp2 ;
44685 PyObject * obj0 = 0 ;
44686 PyObject * obj1 = 0 ;
44687 char *kwnames[] = {
44688 (char *) "self",(char *) "pt", NULL
44689 };
44690
44691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44693 if (SWIG_arg_fail(1)) SWIG_fail;
44694 {
44695 arg2 = &temp2;
44696 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44697 }
44698 {
44699 PyThreadState* __tstate = wxPyBeginAllowThreads();
44700 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44701
44702 wxPyEndAllowThreads(__tstate);
44703 if (PyErr_Occurred()) SWIG_fail;
44704 }
44705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44706 return resultobj;
44707 fail:
44708 return NULL;
44709 }
44710
44711
44712 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44713 PyObject *resultobj;
44714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44715 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44716 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44717 bool result;
44718 PyObject * obj0 = 0 ;
44719 PyObject * obj1 = 0 ;
44720 PyObject * obj2 = 0 ;
44721 char *kwnames[] = {
44722 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44723 };
44724
44725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44727 if (SWIG_arg_fail(1)) SWIG_fail;
44728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44729 if (SWIG_arg_fail(2)) SWIG_fail;
44730 if (obj2) {
44731 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44732 if (SWIG_arg_fail(3)) SWIG_fail;
44733 }
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44737
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 {
44742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44743 }
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44751 PyObject *resultobj;
44752 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44753 wxGBPosition *arg2 = 0 ;
44754 wxGBSpan *arg3 = 0 ;
44755 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44756 bool result;
44757 wxGBPosition temp2 ;
44758 wxGBSpan temp3 ;
44759 PyObject * obj0 = 0 ;
44760 PyObject * obj1 = 0 ;
44761 PyObject * obj2 = 0 ;
44762 PyObject * obj3 = 0 ;
44763 char *kwnames[] = {
44764 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44765 };
44766
44767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44769 if (SWIG_arg_fail(1)) SWIG_fail;
44770 {
44771 arg2 = &temp2;
44772 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44773 }
44774 {
44775 arg3 = &temp3;
44776 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44777 }
44778 if (obj3) {
44779 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44780 if (SWIG_arg_fail(4)) SWIG_fail;
44781 }
44782 {
44783 PyThreadState* __tstate = wxPyBeginAllowThreads();
44784 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44785
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 {
44790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44791 }
44792 return resultobj;
44793 fail:
44794 return NULL;
44795 }
44796
44797
44798 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44799 PyObject *obj;
44800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44801 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44802 Py_INCREF(obj);
44803 return Py_BuildValue((char *)"");
44804 }
44805 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44806 PyObject *resultobj;
44807 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44808 wxRelationship arg2 ;
44809 wxWindow *arg3 = (wxWindow *) 0 ;
44810 wxEdge arg4 ;
44811 int arg5 = (int) 0 ;
44812 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44813 PyObject * obj0 = 0 ;
44814 PyObject * obj1 = 0 ;
44815 PyObject * obj2 = 0 ;
44816 PyObject * obj3 = 0 ;
44817 PyObject * obj4 = 0 ;
44818 PyObject * obj5 = 0 ;
44819 char *kwnames[] = {
44820 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44821 };
44822
44823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44825 if (SWIG_arg_fail(1)) SWIG_fail;
44826 {
44827 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44828 if (SWIG_arg_fail(2)) SWIG_fail;
44829 }
44830 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44831 if (SWIG_arg_fail(3)) SWIG_fail;
44832 {
44833 arg4 = (wxEdge)(SWIG_As_int(obj3));
44834 if (SWIG_arg_fail(4)) SWIG_fail;
44835 }
44836 if (obj4) {
44837 {
44838 arg5 = (int)(SWIG_As_int(obj4));
44839 if (SWIG_arg_fail(5)) SWIG_fail;
44840 }
44841 }
44842 if (obj5) {
44843 {
44844 arg6 = (int)(SWIG_As_int(obj5));
44845 if (SWIG_arg_fail(6)) SWIG_fail;
44846 }
44847 }
44848 {
44849 PyThreadState* __tstate = wxPyBeginAllowThreads();
44850 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44851
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 Py_INCREF(Py_None); resultobj = Py_None;
44856 return resultobj;
44857 fail:
44858 return NULL;
44859 }
44860
44861
44862 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44863 PyObject *resultobj;
44864 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44865 wxWindow *arg2 = (wxWindow *) 0 ;
44866 int arg3 = (int) 0 ;
44867 PyObject * obj0 = 0 ;
44868 PyObject * obj1 = 0 ;
44869 PyObject * obj2 = 0 ;
44870 char *kwnames[] = {
44871 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44872 };
44873
44874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44876 if (SWIG_arg_fail(1)) SWIG_fail;
44877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44878 if (SWIG_arg_fail(2)) SWIG_fail;
44879 if (obj2) {
44880 {
44881 arg3 = (int)(SWIG_As_int(obj2));
44882 if (SWIG_arg_fail(3)) SWIG_fail;
44883 }
44884 }
44885 {
44886 PyThreadState* __tstate = wxPyBeginAllowThreads();
44887 (arg1)->LeftOf(arg2,arg3);
44888
44889 wxPyEndAllowThreads(__tstate);
44890 if (PyErr_Occurred()) SWIG_fail;
44891 }
44892 Py_INCREF(Py_None); resultobj = Py_None;
44893 return resultobj;
44894 fail:
44895 return NULL;
44896 }
44897
44898
44899 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44900 PyObject *resultobj;
44901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44902 wxWindow *arg2 = (wxWindow *) 0 ;
44903 int arg3 = (int) 0 ;
44904 PyObject * obj0 = 0 ;
44905 PyObject * obj1 = 0 ;
44906 PyObject * obj2 = 0 ;
44907 char *kwnames[] = {
44908 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44909 };
44910
44911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44913 if (SWIG_arg_fail(1)) SWIG_fail;
44914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44915 if (SWIG_arg_fail(2)) SWIG_fail;
44916 if (obj2) {
44917 {
44918 arg3 = (int)(SWIG_As_int(obj2));
44919 if (SWIG_arg_fail(3)) SWIG_fail;
44920 }
44921 }
44922 {
44923 PyThreadState* __tstate = wxPyBeginAllowThreads();
44924 (arg1)->RightOf(arg2,arg3);
44925
44926 wxPyEndAllowThreads(__tstate);
44927 if (PyErr_Occurred()) SWIG_fail;
44928 }
44929 Py_INCREF(Py_None); resultobj = Py_None;
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44937 PyObject *resultobj;
44938 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44939 wxWindow *arg2 = (wxWindow *) 0 ;
44940 int arg3 = (int) 0 ;
44941 PyObject * obj0 = 0 ;
44942 PyObject * obj1 = 0 ;
44943 PyObject * obj2 = 0 ;
44944 char *kwnames[] = {
44945 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44946 };
44947
44948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44950 if (SWIG_arg_fail(1)) SWIG_fail;
44951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44952 if (SWIG_arg_fail(2)) SWIG_fail;
44953 if (obj2) {
44954 {
44955 arg3 = (int)(SWIG_As_int(obj2));
44956 if (SWIG_arg_fail(3)) SWIG_fail;
44957 }
44958 }
44959 {
44960 PyThreadState* __tstate = wxPyBeginAllowThreads();
44961 (arg1)->Above(arg2,arg3);
44962
44963 wxPyEndAllowThreads(__tstate);
44964 if (PyErr_Occurred()) SWIG_fail;
44965 }
44966 Py_INCREF(Py_None); resultobj = Py_None;
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj;
44975 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44976 wxWindow *arg2 = (wxWindow *) 0 ;
44977 int arg3 = (int) 0 ;
44978 PyObject * obj0 = 0 ;
44979 PyObject * obj1 = 0 ;
44980 PyObject * obj2 = 0 ;
44981 char *kwnames[] = {
44982 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44983 };
44984
44985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44987 if (SWIG_arg_fail(1)) SWIG_fail;
44988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44989 if (SWIG_arg_fail(2)) SWIG_fail;
44990 if (obj2) {
44991 {
44992 arg3 = (int)(SWIG_As_int(obj2));
44993 if (SWIG_arg_fail(3)) SWIG_fail;
44994 }
44995 }
44996 {
44997 PyThreadState* __tstate = wxPyBeginAllowThreads();
44998 (arg1)->Below(arg2,arg3);
44999
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 Py_INCREF(Py_None); resultobj = Py_None;
45004 return resultobj;
45005 fail:
45006 return NULL;
45007 }
45008
45009
45010 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45011 PyObject *resultobj;
45012 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45013 wxWindow *arg2 = (wxWindow *) 0 ;
45014 wxEdge arg3 ;
45015 int arg4 = (int) 0 ;
45016 PyObject * obj0 = 0 ;
45017 PyObject * obj1 = 0 ;
45018 PyObject * obj2 = 0 ;
45019 PyObject * obj3 = 0 ;
45020 char *kwnames[] = {
45021 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45022 };
45023
45024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45026 if (SWIG_arg_fail(1)) SWIG_fail;
45027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45028 if (SWIG_arg_fail(2)) SWIG_fail;
45029 {
45030 arg3 = (wxEdge)(SWIG_As_int(obj2));
45031 if (SWIG_arg_fail(3)) SWIG_fail;
45032 }
45033 if (obj3) {
45034 {
45035 arg4 = (int)(SWIG_As_int(obj3));
45036 if (SWIG_arg_fail(4)) SWIG_fail;
45037 }
45038 }
45039 {
45040 PyThreadState* __tstate = wxPyBeginAllowThreads();
45041 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
45042
45043 wxPyEndAllowThreads(__tstate);
45044 if (PyErr_Occurred()) SWIG_fail;
45045 }
45046 Py_INCREF(Py_None); resultobj = Py_None;
45047 return resultobj;
45048 fail:
45049 return NULL;
45050 }
45051
45052
45053 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45054 PyObject *resultobj;
45055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45056 wxWindow *arg2 = (wxWindow *) 0 ;
45057 wxEdge arg3 ;
45058 int arg4 ;
45059 PyObject * obj0 = 0 ;
45060 PyObject * obj1 = 0 ;
45061 PyObject * obj2 = 0 ;
45062 PyObject * obj3 = 0 ;
45063 char *kwnames[] = {
45064 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45065 };
45066
45067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45069 if (SWIG_arg_fail(1)) SWIG_fail;
45070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45071 if (SWIG_arg_fail(2)) SWIG_fail;
45072 {
45073 arg3 = (wxEdge)(SWIG_As_int(obj2));
45074 if (SWIG_arg_fail(3)) SWIG_fail;
45075 }
45076 {
45077 arg4 = (int)(SWIG_As_int(obj3));
45078 if (SWIG_arg_fail(4)) SWIG_fail;
45079 }
45080 {
45081 PyThreadState* __tstate = wxPyBeginAllowThreads();
45082 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
45083
45084 wxPyEndAllowThreads(__tstate);
45085 if (PyErr_Occurred()) SWIG_fail;
45086 }
45087 Py_INCREF(Py_None); resultobj = Py_None;
45088 return resultobj;
45089 fail:
45090 return NULL;
45091 }
45092
45093
45094 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45095 PyObject *resultobj;
45096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45097 int arg2 ;
45098 PyObject * obj0 = 0 ;
45099 PyObject * obj1 = 0 ;
45100 char *kwnames[] = {
45101 (char *) "self",(char *) "val", NULL
45102 };
45103
45104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45106 if (SWIG_arg_fail(1)) SWIG_fail;
45107 {
45108 arg2 = (int)(SWIG_As_int(obj1));
45109 if (SWIG_arg_fail(2)) SWIG_fail;
45110 }
45111 {
45112 PyThreadState* __tstate = wxPyBeginAllowThreads();
45113 (arg1)->Absolute(arg2);
45114
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 Py_INCREF(Py_None); resultobj = Py_None;
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj;
45127 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45128 PyObject * obj0 = 0 ;
45129 char *kwnames[] = {
45130 (char *) "self", NULL
45131 };
45132
45133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45135 if (SWIG_arg_fail(1)) SWIG_fail;
45136 {
45137 PyThreadState* __tstate = wxPyBeginAllowThreads();
45138 (arg1)->Unconstrained();
45139
45140 wxPyEndAllowThreads(__tstate);
45141 if (PyErr_Occurred()) SWIG_fail;
45142 }
45143 Py_INCREF(Py_None); resultobj = Py_None;
45144 return resultobj;
45145 fail:
45146 return NULL;
45147 }
45148
45149
45150 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45151 PyObject *resultobj;
45152 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45153 PyObject * obj0 = 0 ;
45154 char *kwnames[] = {
45155 (char *) "self", NULL
45156 };
45157
45158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(1)) SWIG_fail;
45161 {
45162 PyThreadState* __tstate = wxPyBeginAllowThreads();
45163 (arg1)->AsIs();
45164
45165 wxPyEndAllowThreads(__tstate);
45166 if (PyErr_Occurred()) SWIG_fail;
45167 }
45168 Py_INCREF(Py_None); resultobj = Py_None;
45169 return resultobj;
45170 fail:
45171 return NULL;
45172 }
45173
45174
45175 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45176 PyObject *resultobj;
45177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45178 wxWindow *result;
45179 PyObject * obj0 = 0 ;
45180 char *kwnames[] = {
45181 (char *) "self", NULL
45182 };
45183
45184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45186 if (SWIG_arg_fail(1)) SWIG_fail;
45187 {
45188 PyThreadState* __tstate = wxPyBeginAllowThreads();
45189 result = (wxWindow *)(arg1)->GetOtherWindow();
45190
45191 wxPyEndAllowThreads(__tstate);
45192 if (PyErr_Occurred()) SWIG_fail;
45193 }
45194 {
45195 resultobj = wxPyMake_wxObject(result, 0);
45196 }
45197 return resultobj;
45198 fail:
45199 return NULL;
45200 }
45201
45202
45203 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45204 PyObject *resultobj;
45205 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45206 wxEdge result;
45207 PyObject * obj0 = 0 ;
45208 char *kwnames[] = {
45209 (char *) "self", NULL
45210 };
45211
45212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45214 if (SWIG_arg_fail(1)) SWIG_fail;
45215 {
45216 PyThreadState* __tstate = wxPyBeginAllowThreads();
45217 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45218
45219 wxPyEndAllowThreads(__tstate);
45220 if (PyErr_Occurred()) SWIG_fail;
45221 }
45222 resultobj = SWIG_From_int((result));
45223 return resultobj;
45224 fail:
45225 return NULL;
45226 }
45227
45228
45229 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45230 PyObject *resultobj;
45231 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45232 wxEdge arg2 ;
45233 PyObject * obj0 = 0 ;
45234 PyObject * obj1 = 0 ;
45235 char *kwnames[] = {
45236 (char *) "self",(char *) "which", NULL
45237 };
45238
45239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45241 if (SWIG_arg_fail(1)) SWIG_fail;
45242 {
45243 arg2 = (wxEdge)(SWIG_As_int(obj1));
45244 if (SWIG_arg_fail(2)) SWIG_fail;
45245 }
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 (arg1)->SetEdge((wxEdge )arg2);
45249
45250 wxPyEndAllowThreads(__tstate);
45251 if (PyErr_Occurred()) SWIG_fail;
45252 }
45253 Py_INCREF(Py_None); resultobj = Py_None;
45254 return resultobj;
45255 fail:
45256 return NULL;
45257 }
45258
45259
45260 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45261 PyObject *resultobj;
45262 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45263 int arg2 ;
45264 PyObject * obj0 = 0 ;
45265 PyObject * obj1 = 0 ;
45266 char *kwnames[] = {
45267 (char *) "self",(char *) "v", NULL
45268 };
45269
45270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45272 if (SWIG_arg_fail(1)) SWIG_fail;
45273 {
45274 arg2 = (int)(SWIG_As_int(obj1));
45275 if (SWIG_arg_fail(2)) SWIG_fail;
45276 }
45277 {
45278 PyThreadState* __tstate = wxPyBeginAllowThreads();
45279 (arg1)->SetValue(arg2);
45280
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 Py_INCREF(Py_None); resultobj = Py_None;
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45292 PyObject *resultobj;
45293 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45294 int result;
45295 PyObject * obj0 = 0 ;
45296 char *kwnames[] = {
45297 (char *) "self", NULL
45298 };
45299
45300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45302 if (SWIG_arg_fail(1)) SWIG_fail;
45303 {
45304 PyThreadState* __tstate = wxPyBeginAllowThreads();
45305 result = (int)(arg1)->GetMargin();
45306
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 {
45311 resultobj = SWIG_From_int((int)(result));
45312 }
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45320 PyObject *resultobj;
45321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45322 int arg2 ;
45323 PyObject * obj0 = 0 ;
45324 PyObject * obj1 = 0 ;
45325 char *kwnames[] = {
45326 (char *) "self",(char *) "m", NULL
45327 };
45328
45329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45331 if (SWIG_arg_fail(1)) SWIG_fail;
45332 {
45333 arg2 = (int)(SWIG_As_int(obj1));
45334 if (SWIG_arg_fail(2)) SWIG_fail;
45335 }
45336 {
45337 PyThreadState* __tstate = wxPyBeginAllowThreads();
45338 (arg1)->SetMargin(arg2);
45339
45340 wxPyEndAllowThreads(__tstate);
45341 if (PyErr_Occurred()) SWIG_fail;
45342 }
45343 Py_INCREF(Py_None); resultobj = Py_None;
45344 return resultobj;
45345 fail:
45346 return NULL;
45347 }
45348
45349
45350 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45351 PyObject *resultobj;
45352 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45353 int result;
45354 PyObject * obj0 = 0 ;
45355 char *kwnames[] = {
45356 (char *) "self", NULL
45357 };
45358
45359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45361 if (SWIG_arg_fail(1)) SWIG_fail;
45362 {
45363 PyThreadState* __tstate = wxPyBeginAllowThreads();
45364 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45365
45366 wxPyEndAllowThreads(__tstate);
45367 if (PyErr_Occurred()) SWIG_fail;
45368 }
45369 {
45370 resultobj = SWIG_From_int((int)(result));
45371 }
45372 return resultobj;
45373 fail:
45374 return NULL;
45375 }
45376
45377
45378 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45379 PyObject *resultobj;
45380 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45381 int result;
45382 PyObject * obj0 = 0 ;
45383 char *kwnames[] = {
45384 (char *) "self", NULL
45385 };
45386
45387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45389 if (SWIG_arg_fail(1)) SWIG_fail;
45390 {
45391 PyThreadState* __tstate = wxPyBeginAllowThreads();
45392 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45393
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 {
45398 resultobj = SWIG_From_int((int)(result));
45399 }
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45407 PyObject *resultobj;
45408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45409 int result;
45410 PyObject * obj0 = 0 ;
45411 char *kwnames[] = {
45412 (char *) "self", NULL
45413 };
45414
45415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45417 if (SWIG_arg_fail(1)) SWIG_fail;
45418 {
45419 PyThreadState* __tstate = wxPyBeginAllowThreads();
45420 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45421
45422 wxPyEndAllowThreads(__tstate);
45423 if (PyErr_Occurred()) SWIG_fail;
45424 }
45425 {
45426 resultobj = SWIG_From_int((int)(result));
45427 }
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45435 PyObject *resultobj;
45436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45437 bool result;
45438 PyObject * obj0 = 0 ;
45439 char *kwnames[] = {
45440 (char *) "self", NULL
45441 };
45442
45443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45445 if (SWIG_arg_fail(1)) SWIG_fail;
45446 {
45447 PyThreadState* __tstate = wxPyBeginAllowThreads();
45448 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45449
45450 wxPyEndAllowThreads(__tstate);
45451 if (PyErr_Occurred()) SWIG_fail;
45452 }
45453 {
45454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45455 }
45456 return resultobj;
45457 fail:
45458 return NULL;
45459 }
45460
45461
45462 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45463 PyObject *resultobj;
45464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45465 bool arg2 ;
45466 PyObject * obj0 = 0 ;
45467 PyObject * obj1 = 0 ;
45468 char *kwnames[] = {
45469 (char *) "self",(char *) "d", NULL
45470 };
45471
45472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45474 if (SWIG_arg_fail(1)) SWIG_fail;
45475 {
45476 arg2 = (bool)(SWIG_As_bool(obj1));
45477 if (SWIG_arg_fail(2)) SWIG_fail;
45478 }
45479 {
45480 PyThreadState* __tstate = wxPyBeginAllowThreads();
45481 (arg1)->SetDone(arg2);
45482
45483 wxPyEndAllowThreads(__tstate);
45484 if (PyErr_Occurred()) SWIG_fail;
45485 }
45486 Py_INCREF(Py_None); resultobj = Py_None;
45487 return resultobj;
45488 fail:
45489 return NULL;
45490 }
45491
45492
45493 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45494 PyObject *resultobj;
45495 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45496 wxRelationship result;
45497 PyObject * obj0 = 0 ;
45498 char *kwnames[] = {
45499 (char *) "self", NULL
45500 };
45501
45502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45504 if (SWIG_arg_fail(1)) SWIG_fail;
45505 {
45506 PyThreadState* __tstate = wxPyBeginAllowThreads();
45507 result = (wxRelationship)(arg1)->GetRelationship();
45508
45509 wxPyEndAllowThreads(__tstate);
45510 if (PyErr_Occurred()) SWIG_fail;
45511 }
45512 resultobj = SWIG_From_int((result));
45513 return resultobj;
45514 fail:
45515 return NULL;
45516 }
45517
45518
45519 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45520 PyObject *resultobj;
45521 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45522 wxRelationship arg2 ;
45523 PyObject * obj0 = 0 ;
45524 PyObject * obj1 = 0 ;
45525 char *kwnames[] = {
45526 (char *) "self",(char *) "r", NULL
45527 };
45528
45529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45531 if (SWIG_arg_fail(1)) SWIG_fail;
45532 {
45533 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45534 if (SWIG_arg_fail(2)) SWIG_fail;
45535 }
45536 {
45537 PyThreadState* __tstate = wxPyBeginAllowThreads();
45538 (arg1)->SetRelationship((wxRelationship )arg2);
45539
45540 wxPyEndAllowThreads(__tstate);
45541 if (PyErr_Occurred()) SWIG_fail;
45542 }
45543 Py_INCREF(Py_None); resultobj = Py_None;
45544 return resultobj;
45545 fail:
45546 return NULL;
45547 }
45548
45549
45550 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45551 PyObject *resultobj;
45552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45553 wxWindow *arg2 = (wxWindow *) 0 ;
45554 bool result;
45555 PyObject * obj0 = 0 ;
45556 PyObject * obj1 = 0 ;
45557 char *kwnames[] = {
45558 (char *) "self",(char *) "otherW", NULL
45559 };
45560
45561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45563 if (SWIG_arg_fail(1)) SWIG_fail;
45564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45565 if (SWIG_arg_fail(2)) SWIG_fail;
45566 {
45567 PyThreadState* __tstate = wxPyBeginAllowThreads();
45568 result = (bool)(arg1)->ResetIfWin(arg2);
45569
45570 wxPyEndAllowThreads(__tstate);
45571 if (PyErr_Occurred()) SWIG_fail;
45572 }
45573 {
45574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45575 }
45576 return resultobj;
45577 fail:
45578 return NULL;
45579 }
45580
45581
45582 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45583 PyObject *resultobj;
45584 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45585 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45586 wxWindow *arg3 = (wxWindow *) 0 ;
45587 bool result;
45588 PyObject * obj0 = 0 ;
45589 PyObject * obj1 = 0 ;
45590 PyObject * obj2 = 0 ;
45591 char *kwnames[] = {
45592 (char *) "self",(char *) "constraints",(char *) "win", NULL
45593 };
45594
45595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45597 if (SWIG_arg_fail(1)) SWIG_fail;
45598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45599 if (SWIG_arg_fail(2)) SWIG_fail;
45600 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45601 if (SWIG_arg_fail(3)) SWIG_fail;
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45605
45606 wxPyEndAllowThreads(__tstate);
45607 if (PyErr_Occurred()) SWIG_fail;
45608 }
45609 {
45610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45611 }
45612 return resultobj;
45613 fail:
45614 return NULL;
45615 }
45616
45617
45618 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45619 PyObject *resultobj;
45620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45621 wxEdge arg2 ;
45622 wxWindow *arg3 = (wxWindow *) 0 ;
45623 wxWindow *arg4 = (wxWindow *) 0 ;
45624 int result;
45625 PyObject * obj0 = 0 ;
45626 PyObject * obj1 = 0 ;
45627 PyObject * obj2 = 0 ;
45628 PyObject * obj3 = 0 ;
45629 char *kwnames[] = {
45630 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45631 };
45632
45633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45635 if (SWIG_arg_fail(1)) SWIG_fail;
45636 {
45637 arg2 = (wxEdge)(SWIG_As_int(obj1));
45638 if (SWIG_arg_fail(2)) SWIG_fail;
45639 }
45640 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45641 if (SWIG_arg_fail(3)) SWIG_fail;
45642 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45643 if (SWIG_arg_fail(4)) SWIG_fail;
45644 {
45645 PyThreadState* __tstate = wxPyBeginAllowThreads();
45646 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45647
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 {
45652 resultobj = SWIG_From_int((int)(result));
45653 }
45654 return resultobj;
45655 fail:
45656 return NULL;
45657 }
45658
45659
45660 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45661 PyObject *obj;
45662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45663 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45664 Py_INCREF(obj);
45665 return Py_BuildValue((char *)"");
45666 }
45667 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45668 PyObject *resultobj;
45669 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45670 wxIndividualLayoutConstraint *result;
45671 PyObject * obj0 = 0 ;
45672 char *kwnames[] = {
45673 (char *) "self", NULL
45674 };
45675
45676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45678 if (SWIG_arg_fail(1)) SWIG_fail;
45679 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45680
45681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45682 return resultobj;
45683 fail:
45684 return NULL;
45685 }
45686
45687
45688 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45689 PyObject *resultobj;
45690 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45691 wxIndividualLayoutConstraint *result;
45692 PyObject * obj0 = 0 ;
45693 char *kwnames[] = {
45694 (char *) "self", NULL
45695 };
45696
45697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45699 if (SWIG_arg_fail(1)) SWIG_fail;
45700 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45701
45702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45703 return resultobj;
45704 fail:
45705 return NULL;
45706 }
45707
45708
45709 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45710 PyObject *resultobj;
45711 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45712 wxIndividualLayoutConstraint *result;
45713 PyObject * obj0 = 0 ;
45714 char *kwnames[] = {
45715 (char *) "self", NULL
45716 };
45717
45718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45720 if (SWIG_arg_fail(1)) SWIG_fail;
45721 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45722
45723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45731 PyObject *resultobj;
45732 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45733 wxIndividualLayoutConstraint *result;
45734 PyObject * obj0 = 0 ;
45735 char *kwnames[] = {
45736 (char *) "self", NULL
45737 };
45738
45739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45741 if (SWIG_arg_fail(1)) SWIG_fail;
45742 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45743
45744 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj;
45753 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45754 wxIndividualLayoutConstraint *result;
45755 PyObject * obj0 = 0 ;
45756 char *kwnames[] = {
45757 (char *) "self", NULL
45758 };
45759
45760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45762 if (SWIG_arg_fail(1)) SWIG_fail;
45763 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45764
45765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45766 return resultobj;
45767 fail:
45768 return NULL;
45769 }
45770
45771
45772 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45773 PyObject *resultobj;
45774 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45775 wxIndividualLayoutConstraint *result;
45776 PyObject * obj0 = 0 ;
45777 char *kwnames[] = {
45778 (char *) "self", NULL
45779 };
45780
45781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45783 if (SWIG_arg_fail(1)) SWIG_fail;
45784 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45785
45786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45787 return resultobj;
45788 fail:
45789 return NULL;
45790 }
45791
45792
45793 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45794 PyObject *resultobj;
45795 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45796 wxIndividualLayoutConstraint *result;
45797 PyObject * obj0 = 0 ;
45798 char *kwnames[] = {
45799 (char *) "self", NULL
45800 };
45801
45802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45804 if (SWIG_arg_fail(1)) SWIG_fail;
45805 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45806
45807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45808 return resultobj;
45809 fail:
45810 return NULL;
45811 }
45812
45813
45814 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45815 PyObject *resultobj;
45816 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45817 wxIndividualLayoutConstraint *result;
45818 PyObject * obj0 = 0 ;
45819 char *kwnames[] = {
45820 (char *) "self", NULL
45821 };
45822
45823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45825 if (SWIG_arg_fail(1)) SWIG_fail;
45826 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45827
45828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45829 return resultobj;
45830 fail:
45831 return NULL;
45832 }
45833
45834
45835 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45836 PyObject *resultobj;
45837 wxLayoutConstraints *result;
45838 char *kwnames[] = {
45839 NULL
45840 };
45841
45842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45846
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45858 PyObject *resultobj;
45859 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45860 wxWindow *arg2 = (wxWindow *) 0 ;
45861 int *arg3 = (int *) 0 ;
45862 bool result;
45863 int temp3 ;
45864 int res3 = 0 ;
45865 PyObject * obj0 = 0 ;
45866 PyObject * obj1 = 0 ;
45867 char *kwnames[] = {
45868 (char *) "self",(char *) "win", NULL
45869 };
45870
45871 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45874 if (SWIG_arg_fail(1)) SWIG_fail;
45875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45876 if (SWIG_arg_fail(2)) SWIG_fail;
45877 {
45878 PyThreadState* __tstate = wxPyBeginAllowThreads();
45879 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45880
45881 wxPyEndAllowThreads(__tstate);
45882 if (PyErr_Occurred()) SWIG_fail;
45883 }
45884 {
45885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45886 }
45887 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45888 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45889 return resultobj;
45890 fail:
45891 return NULL;
45892 }
45893
45894
45895 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45896 PyObject *resultobj;
45897 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45898 bool result;
45899 PyObject * obj0 = 0 ;
45900 char *kwnames[] = {
45901 (char *) "self", NULL
45902 };
45903
45904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45906 if (SWIG_arg_fail(1)) SWIG_fail;
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45910
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 {
45915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45916 }
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45924 PyObject *obj;
45925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45926 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45927 Py_INCREF(obj);
45928 return Py_BuildValue((char *)"");
45929 }
45930 static PyMethodDef SwigMethods[] = {
45931 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45932 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45933 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45936 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45957 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45970 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45985 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46039 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46067 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46086 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46088 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46096 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46097 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46109 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46121 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46125 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46131 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46141 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46151 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46154 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46161 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46169 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46177 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46260 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46262 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46264 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46266 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46268 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46270 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46272 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46274 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46276 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46278 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46280 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46282 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46284 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46298 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46316 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46319 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46322 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46334 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46339 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46345 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46351 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46414 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46421 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46457 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46467 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46473 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46475 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46477 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46480 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46484 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46487 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46490 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46492 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46497 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46505 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46509 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46514 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46535 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46537 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46540 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46546 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46550 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46561 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46564 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46567 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46571 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46578 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46583 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46588 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46592 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46637 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46657 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46664 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46668 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46678 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46849 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46890 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46905 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46908 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46963 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46992 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47036 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47044 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47063 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47064 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47101 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47131 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47134 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47138 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47141 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47151 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47163 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47175 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47185 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47195 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47209 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47216 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47217 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47218 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47219 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47220 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47225 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47252 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47264 { NULL, NULL, 0, NULL }
47265 };
47266
47267
47268 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47269
47270 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47271 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47272 }
47273 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47274 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47275 }
47276 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47277 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47278 }
47279 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47280 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47281 }
47282 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47283 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47284 }
47285 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47286 return (void *)((wxSizer *) ((wxGridSizer *) x));
47287 }
47288 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47289 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47290 }
47291 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47292 return (void *)((wxSizer *) ((wxPySizer *) x));
47293 }
47294 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47295 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47296 }
47297 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47298 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47299 }
47300 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47301 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47302 }
47303 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47304 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47305 }
47306 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47307 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47308 }
47309 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47310 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47311 }
47312 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47313 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47314 }
47315 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47316 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47317 }
47318 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47319 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47320 }
47321 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47322 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47323 }
47324 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47325 return (void *)((wxEvent *) ((wxPyEvent *) x));
47326 }
47327 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47328 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47329 }
47330 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47331 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47332 }
47333 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47334 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47335 }
47336 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47337 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47338 }
47339 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47340 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47341 }
47342 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47343 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47344 }
47345 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47346 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47347 }
47348 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47349 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47350 }
47351 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47352 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47353 }
47354 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47355 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47356 }
47357 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47358 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47359 }
47360 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47361 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47362 }
47363 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47364 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47365 }
47366 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47367 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47368 }
47369 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47370 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47371 }
47372 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47373 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47374 }
47375 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47376 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47377 }
47378 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47379 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47380 }
47381 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47382 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47383 }
47384 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47385 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47386 }
47387 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47388 return (void *)((wxEvent *) ((wxShowEvent *) x));
47389 }
47390 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47391 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47392 }
47393 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47394 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47395 }
47396 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47397 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47398 }
47399 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47400 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47401 }
47402 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47403 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47404 }
47405 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47406 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47407 }
47408 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47409 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47410 }
47411 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47412 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47413 }
47414 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47415 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47416 }
47417 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47418 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47419 }
47420 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47421 return (void *)((wxControl *) ((wxControlWithItems *) x));
47422 }
47423 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47424 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47425 }
47426 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47427 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47428 }
47429 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47430 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47431 }
47432 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47433 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47434 }
47435 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47436 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47437 }
47438 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47439 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47440 }
47441 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47442 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47443 }
47444 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47445 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47446 }
47447 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47448 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47449 }
47450 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47451 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47452 }
47453 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47454 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47455 }
47456 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47457 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47458 }
47459 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47460 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47461 }
47462 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47463 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47464 }
47465 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47466 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47467 }
47468 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47469 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47470 }
47471 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47472 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47473 }
47474 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47475 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47476 }
47477 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47478 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47479 }
47480 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47481 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47482 }
47483 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47484 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47485 }
47486 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47487 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47488 }
47489 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47490 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47491 }
47492 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47493 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47494 }
47495 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47496 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47497 }
47498 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47499 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47500 }
47501 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47502 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47503 }
47504 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47505 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47506 }
47507 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47508 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47509 }
47510 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47511 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47512 }
47513 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47514 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47515 }
47516 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47517 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47518 }
47519 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47520 return (void *)((wxObject *) ((wxSizerItem *) x));
47521 }
47522 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47523 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47524 }
47525 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47526 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47527 }
47528 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47529 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47530 }
47531 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47532 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47533 }
47534 static void *_p_wxSizerTo_p_wxObject(void *x) {
47535 return (void *)((wxObject *) ((wxSizer *) x));
47536 }
47537 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47538 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47539 }
47540 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47542 }
47543 static void *_p_wxEventTo_p_wxObject(void *x) {
47544 return (void *)((wxObject *) ((wxEvent *) x));
47545 }
47546 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47547 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47548 }
47549 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47550 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47551 }
47552 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47553 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47554 }
47555 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47556 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47557 }
47558 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47559 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47560 }
47561 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47562 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47563 }
47564 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47565 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47566 }
47567 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47568 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47569 }
47570 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47571 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47572 }
47573 static void *_p_wxControlTo_p_wxObject(void *x) {
47574 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47575 }
47576 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47577 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47578 }
47579 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47580 return (void *)((wxObject *) ((wxFSFile *) x));
47581 }
47582 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47583 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47584 }
47585 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47586 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47587 }
47588 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47589 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47590 }
47591 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47592 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47593 }
47594 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47595 return (void *)((wxObject *) ((wxMenuItem *) x));
47596 }
47597 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47598 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47599 }
47600 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47601 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47602 }
47603 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47604 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47605 }
47606 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47607 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47608 }
47609 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47610 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47611 }
47612 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47613 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47614 }
47615 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47616 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47617 }
47618 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47619 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47620 }
47621 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47622 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47623 }
47624 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47625 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47626 }
47627 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47628 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47629 }
47630 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47631 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47632 }
47633 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47634 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47635 }
47636 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47637 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47638 }
47639 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47640 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47641 }
47642 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47643 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47644 }
47645 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47646 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47647 }
47648 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47649 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47650 }
47651 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47652 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47653 }
47654 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47655 return (void *)((wxObject *) ((wxImageHandler *) x));
47656 }
47657 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47658 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47659 }
47660 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47661 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47662 }
47663 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47664 return (void *)((wxObject *) ((wxEvtHandler *) x));
47665 }
47666 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47667 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47668 }
47669 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47670 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47671 }
47672 static void *_p_wxImageTo_p_wxObject(void *x) {
47673 return (void *)((wxObject *) ((wxImage *) x));
47674 }
47675 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47676 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47677 }
47678 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47680 }
47681 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47682 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47683 }
47684 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47685 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47686 }
47687 static void *_p_wxWindowTo_p_wxObject(void *x) {
47688 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47689 }
47690 static void *_p_wxMenuTo_p_wxObject(void *x) {
47691 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47692 }
47693 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47694 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47695 }
47696 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47697 return (void *)((wxObject *) ((wxFileSystem *) x));
47698 }
47699 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47701 }
47702 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47703 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47704 }
47705 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47706 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47707 }
47708 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47709 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47710 }
47711 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47712 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47713 }
47714 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47715 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47716 }
47717 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47718 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47719 }
47720 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47721 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47722 }
47723 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47724 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47725 }
47726 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47727 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47728 }
47729 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47730 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47731 }
47732 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47733 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47734 }
47735 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47736 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47737 }
47738 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47739 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47740 }
47741 static void *_p_wxControlTo_p_wxWindow(void *x) {
47742 return (void *)((wxWindow *) ((wxControl *) x));
47743 }
47744 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47745 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47746 }
47747 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47748 return (void *)((wxWindow *) ((wxMenuBar *) x));
47749 }
47750 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47751 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47752 }
47753 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47754 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47755 }
47756 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47757 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47758 }
47759 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47760 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47761 }
47762 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47763 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47764 }
47765 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47766 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47767 }
47768 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47769 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47770 }
47771 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47772 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47773 }
47774 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47775 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47776 }
47777 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47778 return (void *)((wxValidator *) ((wxPyValidator *) x));
47779 }
47780 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}};
47781 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}};
47782 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}};
47783 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}};
47784 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}};
47785 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}};
47786 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}};
47787 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}};
47788 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}};
47789 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}};
47790 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}};
47791 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}};
47792 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}};
47793 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47794 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47795 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}};
47796 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}};
47797 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}};
47798 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}};
47799 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}};
47800 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}};
47801 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}};
47802 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}};
47803 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}};
47804 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}};
47805 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}};
47806 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}};
47807 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}};
47808 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}};
47809 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}};
47810 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}};
47811 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}};
47812 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}};
47813 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}};
47814 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}};
47815 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}};
47816 static swig_type_info _swigt__p_wxImage_HSVValue[] = {{"_p_wxImage_HSVValue", 0, "wxImage_HSVValue *", 0, 0, 0, 0},{"_p_wxImage_HSVValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47817 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}};
47818 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}};
47819 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}};
47820 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}};
47821 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}};
47822 static swig_type_info _swigt__p_wxImage_RGBValue[] = {{"_p_wxImage_RGBValue", 0, "wxImage_RGBValue *", 0, 0, 0, 0},{"_p_wxImage_RGBValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47823 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}};
47824 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}};
47825 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}};
47826 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}};
47827 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}};
47828 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}};
47829 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}};
47830 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}};
47831 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}};
47832 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}};
47833 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}};
47834 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}};
47835 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}};
47836 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}};
47837 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}};
47838 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}};
47839 static swig_type_info _swigt__p_wxDateEvent[] = {{"_p_wxDateEvent", 0, "wxDateEvent *", 0, 0, 0, 0},{"_p_wxDateEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47840 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}};
47841 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}};
47842 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}};
47843 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}};
47844 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}};
47845 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}};
47846 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}};
47847 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}};
47848 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}};
47849 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}};
47850 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}};
47851 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}};
47852 static swig_type_info _swigt__p_wxPyImageHandler[] = {{"_p_wxPyImageHandler", 0, "wxPyImageHandler *", 0, 0, 0, 0},{"_p_wxPyImageHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47853 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}};
47854 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}};
47855 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}};
47856 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}};
47857 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}};
47858 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}};
47859 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}};
47860 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}};
47861 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxImageHandler, 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}};
47862 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}};
47863 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}};
47864 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}};
47865 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}};
47866 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}};
47867 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}};
47868 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}};
47869 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}};
47870 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}};
47871 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}};
47872 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}};
47873 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}};
47874 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}};
47875 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}};
47876 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}};
47877 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}};
47878 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_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_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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}};
47879 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}};
47880 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}};
47881 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}};
47882 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}};
47883 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}};
47884 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}};
47885 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}};
47886 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}};
47887 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}};
47888 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}};
47889 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}};
47890 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}};
47891 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}};
47892 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}};
47893 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}};
47894 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}};
47895 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}};
47896 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}};
47897 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}};
47898 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}};
47899 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}};
47900 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47901 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}};
47902 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}};
47903 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}};
47904 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}};
47905 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}};
47906 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}};
47907 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}};
47908 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}};
47909 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}};
47910 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}};
47911
47912 static swig_type_info *swig_types_initial[] = {
47913 _swigt__p_wxLayoutConstraints,
47914 _swigt__p_wxRealPoint,
47915 _swigt__p_wxSizerItem,
47916 _swigt__p_wxGBSizerItem,
47917 _swigt__p_wxScrollEvent,
47918 _swigt__p_wxEventLoop,
47919 _swigt__p_wxIndividualLayoutConstraint,
47920 _swigt__p_wxSizer,
47921 _swigt__p_wxBoxSizer,
47922 _swigt__p_wxStaticBoxSizer,
47923 _swigt__p_wxGridBagSizer,
47924 _swigt__p_wxAcceleratorEntry,
47925 _swigt__p_wxUpdateUIEvent,
47926 _swigt__p_wxEvent,
47927 _swigt__p_buffer,
47928 _swigt__p_wxMenu,
47929 _swigt__p_wxGridSizer,
47930 _swigt__p_wxFlexGridSizer,
47931 _swigt__p_wxInitDialogEvent,
47932 _swigt__p_wxItemContainer,
47933 _swigt__p_wxPaintEvent,
47934 _swigt__p_wxNcPaintEvent,
47935 _swigt__p_wxSysColourChangedEvent,
47936 _swigt__p_wxMouseCaptureChangedEvent,
47937 _swigt__p_wxDisplayChangedEvent,
47938 _swigt__p_wxPaletteChangedEvent,
47939 _swigt__p_wxControl,
47940 _swigt__p_wxFont,
47941 _swigt__p_wxMenuBarBase,
47942 _swigt__p_wxSetCursorEvent,
47943 _swigt__p_wxFSFile,
47944 _swigt__p_wxCaret,
47945 _swigt__ptrdiff_t,
47946 _swigt__std__ptrdiff_t,
47947 _swigt__p_wxRegion,
47948 _swigt__p_wxPoint2D,
47949 _swigt__p_wxImage_HSVValue,
47950 _swigt__p_int,
47951 _swigt__p_wxSize,
47952 _swigt__p_wxDC,
47953 _swigt__p_wxPySizer,
47954 _swigt__p_wxVisualAttributes,
47955 _swigt__p_wxImage_RGBValue,
47956 _swigt__p_wxNotifyEvent,
47957 _swigt__p_wxPyEvent,
47958 _swigt__p_wxPropagationDisabler,
47959 _swigt__p_form_ops_t,
47960 _swigt__p_wxAppTraits,
47961 _swigt__p_wxArrayString,
47962 _swigt__p_wxShowEvent,
47963 _swigt__p_wxToolTip,
47964 _swigt__p_wxMoveEvent,
47965 _swigt__p_wxSizeEvent,
47966 _swigt__p_wxActivateEvent,
47967 _swigt__p_wxIconizeEvent,
47968 _swigt__p_wxMaximizeEvent,
47969 _swigt__p_wxQueryNewPaletteEvent,
47970 _swigt__p_wxWindowCreateEvent,
47971 _swigt__p_wxIdleEvent,
47972 _swigt__p_wxDateEvent,
47973 _swigt__p_wxMenuItem,
47974 _swigt__p_wxStaticBox,
47975 _swigt__p_long,
47976 _swigt__p_wxDuplexMode,
47977 _swigt__p_wxTIFFHandler,
47978 _swigt__p_wxXPMHandler,
47979 _swigt__p_wxPNMHandler,
47980 _swigt__p_wxJPEGHandler,
47981 _swigt__p_wxPCXHandler,
47982 _swigt__p_wxGIFHandler,
47983 _swigt__p_wxPNGHandler,
47984 _swigt__p_wxANIHandler,
47985 _swigt__p_wxPyImageHandler,
47986 _swigt__p_wxMemoryFSHandler,
47987 _swigt__p_wxZipFSHandler,
47988 _swigt__p_wxInternetFSHandler,
47989 _swigt__p_wxPyFileSystemHandler,
47990 _swigt__p_wxEvtHandler,
47991 _swigt__p_wxCURHandler,
47992 _swigt__p_wxICOHandler,
47993 _swigt__p_wxBMPHandler,
47994 _swigt__p_wxImageHandler,
47995 _swigt__p_wxFileSystemHandler,
47996 _swigt__p_wxRect,
47997 _swigt__p_wxButton,
47998 _swigt__p_wxGBSpan,
47999 _swigt__p_wxPropagateOnce,
48000 _swigt__p_wxAcceleratorTable,
48001 _swigt__p_wxStdDialogButtonSizer,
48002 _swigt__p_char,
48003 _swigt__p_wxGBPosition,
48004 _swigt__p_wxImage,
48005 _swigt__p_wxFrame,
48006 _swigt__p_wxScrollWinEvent,
48007 _swigt__p_wxPaperSize,
48008 _swigt__p_wxImageHistogram,
48009 _swigt__p_wxPoint,
48010 _swigt__p_wxCursor,
48011 _swigt__p_wxObject,
48012 _swigt__p_wxInputStream,
48013 _swigt__p_wxOutputStream,
48014 _swigt__p_wxPyInputStream,
48015 _swigt__p_wxDateTime,
48016 _swigt__p_wxKeyEvent,
48017 _swigt__p_wxNavigationKeyEvent,
48018 _swigt__p_wxWindowDestroyEvent,
48019 _swigt__p_unsigned_long,
48020 _swigt__p_wxWindow,
48021 _swigt__p_wxMenuBar,
48022 _swigt__p_wxFileSystem,
48023 _swigt__p_wxBitmap,
48024 _swigt__unsigned_int,
48025 _swigt__p_unsigned_int,
48026 _swigt__p_wxMenuEvent,
48027 _swigt__p_wxContextMenuEvent,
48028 _swigt__p_unsigned_char,
48029 _swigt__p_wxMouseEvent,
48030 _swigt__p_wxEraseEvent,
48031 _swigt__p_wxCloseEvent,
48032 _swigt__p_wxPyApp,
48033 _swigt__p_wxCommandEvent,
48034 _swigt__p_wxPyCommandEvent,
48035 _swigt__p_wxPyDropTarget,
48036 _swigt__p_wxQuantize,
48037 _swigt__p_wxFocusEvent,
48038 _swigt__p_wxChildFocusEvent,
48039 _swigt__p_wxDropFilesEvent,
48040 _swigt__p_wxControlWithItems,
48041 _swigt__p_wxColour,
48042 _swigt__p_wxValidator,
48043 _swigt__p_wxPyValidator,
48044 0
48045 };
48046
48047
48048 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48049
48050 static swig_const_info swig_const_table[] = {
48051 {0, 0, 0, 0.0, 0, 0}};
48052
48053 #ifdef __cplusplus
48054 }
48055 #endif
48056
48057
48058 #ifdef __cplusplus
48059 extern "C" {
48060 #endif
48061
48062 /* Python-specific SWIG API */
48063 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48064 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48065 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48066
48067 /* -----------------------------------------------------------------------------
48068 * global variable support code.
48069 * ----------------------------------------------------------------------------- */
48070
48071 typedef struct swig_globalvar {
48072 char *name; /* Name of global variable */
48073 PyObject *(*get_attr)(); /* Return the current value */
48074 int (*set_attr)(PyObject *); /* Set the value */
48075 struct swig_globalvar *next;
48076 } swig_globalvar;
48077
48078 typedef struct swig_varlinkobject {
48079 PyObject_HEAD
48080 swig_globalvar *vars;
48081 } swig_varlinkobject;
48082
48083 static PyObject *
48084 swig_varlink_repr(swig_varlinkobject *v) {
48085 v = v;
48086 return PyString_FromString("<Swig global variables>");
48087 }
48088
48089 static int
48090 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48091 swig_globalvar *var;
48092 flags = flags;
48093 fprintf(fp,"Swig global variables { ");
48094 for (var = v->vars; var; var=var->next) {
48095 fprintf(fp,"%s", var->name);
48096 if (var->next) fprintf(fp,", ");
48097 }
48098 fprintf(fp," }\n");
48099 return 0;
48100 }
48101
48102 static PyObject *
48103 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48104 swig_globalvar *var = v->vars;
48105 while (var) {
48106 if (strcmp(var->name,n) == 0) {
48107 return (*var->get_attr)();
48108 }
48109 var = var->next;
48110 }
48111 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48112 return NULL;
48113 }
48114
48115 static int
48116 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48117 swig_globalvar *var = v->vars;
48118 while (var) {
48119 if (strcmp(var->name,n) == 0) {
48120 return (*var->set_attr)(p);
48121 }
48122 var = var->next;
48123 }
48124 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48125 return 1;
48126 }
48127
48128 static PyTypeObject varlinktype = {
48129 PyObject_HEAD_INIT(0)
48130 0, /* Number of items in variable part (ob_size) */
48131 (char *)"swigvarlink", /* Type name (tp_name) */
48132 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48133 0, /* Itemsize (tp_itemsize) */
48134 0, /* Deallocator (tp_dealloc) */
48135 (printfunc) swig_varlink_print, /* Print (tp_print) */
48136 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48137 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48138 0, /* tp_compare */
48139 (reprfunc) swig_varlink_repr, /* tp_repr */
48140 0, /* tp_as_number */
48141 0, /* tp_as_sequence */
48142 0, /* tp_as_mapping */
48143 0, /* tp_hash */
48144 0, /* tp_call */
48145 0, /* tp_str */
48146 0, /* tp_getattro */
48147 0, /* tp_setattro */
48148 0, /* tp_as_buffer */
48149 0, /* tp_flags */
48150 0, /* tp_doc */
48151 #if PY_VERSION_HEX >= 0x02000000
48152 0, /* tp_traverse */
48153 0, /* tp_clear */
48154 #endif
48155 #if PY_VERSION_HEX >= 0x02010000
48156 0, /* tp_richcompare */
48157 0, /* tp_weaklistoffset */
48158 #endif
48159 #if PY_VERSION_HEX >= 0x02020000
48160 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48161 #endif
48162 #if PY_VERSION_HEX >= 0x02030000
48163 0, /* tp_del */
48164 #endif
48165 #ifdef COUNT_ALLOCS
48166 0,0,0,0 /* tp_alloc -> tp_next */
48167 #endif
48168 };
48169
48170 /* Create a variable linking object for use later */
48171 static PyObject *
48172 SWIG_Python_newvarlink(void) {
48173 swig_varlinkobject *result = 0;
48174 result = PyMem_NEW(swig_varlinkobject,1);
48175 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
48176 result->ob_type = &varlinktype;
48177 result->vars = 0;
48178 result->ob_refcnt = 0;
48179 Py_XINCREF((PyObject *) result);
48180 return ((PyObject*) result);
48181 }
48182
48183 static void
48184 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48185 swig_varlinkobject *v;
48186 swig_globalvar *gv;
48187 v= (swig_varlinkobject *) p;
48188 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48189 gv->name = (char *) malloc(strlen(name)+1);
48190 strcpy(gv->name,name);
48191 gv->get_attr = get_attr;
48192 gv->set_attr = set_attr;
48193 gv->next = v->vars;
48194 v->vars = gv;
48195 }
48196
48197 /* -----------------------------------------------------------------------------
48198 * constants/methods manipulation
48199 * ----------------------------------------------------------------------------- */
48200
48201 /* Install Constants */
48202 static void
48203 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48204 PyObject *obj = 0;
48205 size_t i;
48206 for (i = 0; constants[i].type; i++) {
48207 switch(constants[i].type) {
48208 case SWIG_PY_INT:
48209 obj = PyInt_FromLong(constants[i].lvalue);
48210 break;
48211 case SWIG_PY_FLOAT:
48212 obj = PyFloat_FromDouble(constants[i].dvalue);
48213 break;
48214 case SWIG_PY_STRING:
48215 if (constants[i].pvalue) {
48216 obj = PyString_FromString((char *) constants[i].pvalue);
48217 } else {
48218 Py_INCREF(Py_None);
48219 obj = Py_None;
48220 }
48221 break;
48222 case SWIG_PY_POINTER:
48223 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48224 break;
48225 case SWIG_PY_BINARY:
48226 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48227 break;
48228 default:
48229 obj = 0;
48230 break;
48231 }
48232 if (obj) {
48233 PyDict_SetItemString(d,constants[i].name,obj);
48234 Py_DECREF(obj);
48235 }
48236 }
48237 }
48238
48239 /* -----------------------------------------------------------------------------*/
48240 /* Fix SwigMethods to carry the callback ptrs when needed */
48241 /* -----------------------------------------------------------------------------*/
48242
48243 static void
48244 SWIG_Python_FixMethods(PyMethodDef *methods,
48245 swig_const_info *const_table,
48246 swig_type_info **types,
48247 swig_type_info **types_initial) {
48248 size_t i;
48249 for (i = 0; methods[i].ml_name; ++i) {
48250 char *c = methods[i].ml_doc;
48251 if (c && (c = strstr(c, "swig_ptr: "))) {
48252 int j;
48253 swig_const_info *ci = 0;
48254 char *name = c + 10;
48255 for (j = 0; const_table[j].type; j++) {
48256 if (strncmp(const_table[j].name, name,
48257 strlen(const_table[j].name)) == 0) {
48258 ci = &(const_table[j]);
48259 break;
48260 }
48261 }
48262 if (ci) {
48263 size_t shift = (ci->ptype) - types;
48264 swig_type_info *ty = types_initial[shift];
48265 size_t ldoc = (c - methods[i].ml_doc);
48266 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
48267 char *ndoc = (char*)malloc(ldoc + lptr + 10);
48268 char *buff = ndoc;
48269 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
48270 strncpy(buff, methods[i].ml_doc, ldoc);
48271 buff += ldoc;
48272 strncpy(buff, "swig_ptr: ", 10);
48273 buff += 10;
48274 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
48275 methods[i].ml_doc = ndoc;
48276 }
48277 }
48278 }
48279 }
48280
48281 /* -----------------------------------------------------------------------------*
48282 * Initialize type list
48283 * -----------------------------------------------------------------------------*/
48284
48285 #if PY_MAJOR_VERSION < 2
48286 /* PyModule_AddObject function was introduced in Python 2.0. The following function
48287 is copied out of Python/modsupport.c in python version 2.3.4 */
48288 static int
48289 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
48290 {
48291 PyObject *dict;
48292 if (!PyModule_Check(m)) {
48293 PyErr_SetString(PyExc_TypeError,
48294 "PyModule_AddObject() needs module as first arg");
48295 return -1;
48296 }
48297 if (!o) {
48298 PyErr_SetString(PyExc_TypeError,
48299 "PyModule_AddObject() needs non-NULL value");
48300 return -1;
48301 }
48302
48303 dict = PyModule_GetDict(m);
48304 if (dict == NULL) {
48305 /* Internal error -- modules must have a dict! */
48306 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
48307 PyModule_GetName(m));
48308 return -1;
48309 }
48310 if (PyDict_SetItemString(dict, name, o))
48311 return -1;
48312 Py_DECREF(o);
48313 return 0;
48314 }
48315 #endif
48316
48317 static swig_type_info **
48318 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
48319 static PyMethodDef swig_empty_runtime_method_table[] = {
48320 {
48321 NULL, NULL, 0, NULL
48322 }
48323 };/* Sentinel */
48324
48325 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
48326 swig_empty_runtime_method_table);
48327 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
48328 if (pointer && module) {
48329 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
48330 }
48331 return type_list_handle;
48332 }
48333
48334 static swig_type_info **
48335 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
48336 swig_type_info **type_pointer;
48337
48338 /* first check if module already created */
48339 type_pointer = SWIG_Python_GetTypeListHandle();
48340 if (type_pointer) {
48341 return type_pointer;
48342 } else {
48343 /* create a new module and variable */
48344 return SWIG_Python_SetTypeListHandle(type_list_handle);
48345 }
48346 }
48347
48348 #ifdef __cplusplus
48349 }
48350 #endif
48351
48352 /* -----------------------------------------------------------------------------*
48353 * Partial Init method
48354 * -----------------------------------------------------------------------------*/
48355
48356 #ifdef SWIG_LINK_RUNTIME
48357 #ifdef __cplusplus
48358 extern "C"
48359 #endif
48360 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
48361 #endif
48362
48363 #ifdef __cplusplus
48364 extern "C"
48365 #endif
48366 SWIGEXPORT(void) SWIG_init(void) {
48367 static PyObject *SWIG_globals = 0;
48368 static int typeinit = 0;
48369 PyObject *m, *d;
48370 int i;
48371 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
48372
48373 /* Fix SwigMethods to carry the callback ptrs when needed */
48374 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
48375
48376 m = Py_InitModule((char *) SWIG_name, SwigMethods);
48377 d = PyModule_GetDict(m);
48378
48379 if (!typeinit) {
48380 #ifdef SWIG_LINK_RUNTIME
48381 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
48382 #else
48383 # ifndef SWIG_STATIC_RUNTIME
48384 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
48385 # endif
48386 #endif
48387 for (i = 0; swig_types_initial[i]; i++) {
48388 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
48389 }
48390 typeinit = 1;
48391 }
48392 SWIG_InstallConstants(d,swig_const_table);
48393
48394
48395 #ifndef wxPyUSE_EXPORT
48396 // Make our API structure a CObject so other modules can import it
48397 // from this module.
48398 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
48399 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
48400 Py_XDECREF(cobj);
48401 #endif
48402
48403 {
48404 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int((int)(wxSIZE_FORCE)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int((int)(wxID_NONE)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
49992 }
49993 {
49994 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
49995 }
49996 {
49997 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
49998 }
49999 {
50000 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
50001 }
50002 {
50003 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
50004 }
50005 {
50006 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
50007 }
50008 {
50009 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
50010 }
50011 {
50012 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
50013 }
50014 {
50015 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50016 }
50017 {
50018 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50019 }
50020 {
50021 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
50022 }
50023 {
50024 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
50025 }
50026 {
50027 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
50028 }
50029 {
50030 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
50031 }
50032 {
50033 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
50034 }
50035 {
50036 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
50073 }
50074 {
50075 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
50076 }
50077 {
50078 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
50079 }
50080 {
50081 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
50082 }
50083 {
50084 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
50085 }
50086 {
50087 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
50088 }
50089 {
50090 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
50091 }
50092 {
50093 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
50094 }
50095 {
50096 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
50109 }
50110 {
50111 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
50118 }
50119 {
50120 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
50121 }
50122 {
50123 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int((int)(wxMOD_ALTGR)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"MOD_META", SWIG_From_int((int)(wxMOD_META)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int((int)(wxMOD_CMD)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int((int)(wxMOD_ALL)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
50235 }
50236 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50237 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50238 {
50239 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
50240 }
50241 {
50242 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
50243 }
50244 {
50245 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
50246 }
50247 {
50248 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
50249 }
50250 {
50251 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
50252 }
50253 {
50254 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
50255 }
50256 {
50257 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
50258 }
50259 {
50260 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
50261 }
50262 {
50263 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
50264 }
50265 {
50266 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
50267 }
50268 {
50269 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
50270 }
50271 {
50272 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
50273 }
50274 {
50275 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
50276 }
50277 {
50278 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
50279 }
50280 {
50281 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
50282 }
50283 {
50284 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
50285 }
50286 {
50287 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
50288 }
50289 {
50290 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
50291 }
50292 {
50293 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
50294 }
50295 {
50296 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
50297 }
50298 {
50299 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
50300 }
50301 {
50302 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
50303 }
50304 {
50305 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
50306 }
50307 {
50308 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
50315 }
50316 {
50317 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
50318 }
50319 {
50320 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
50321 }
50322 {
50323 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
50330 }
50331 {
50332 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
50333 }
50334 {
50335 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
50336 }
50337 {
50338 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
50339 }
50340 {
50341 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
50342 }
50343 {
50344 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
50345 }
50346 {
50347 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
50348 }
50349 {
50350 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
50351 }
50352 {
50353 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
50354 }
50355 {
50356 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
50357 }
50358 {
50359 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
50360 }
50361 {
50362 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
50363 }
50364 {
50365 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
50366 }
50367 {
50368 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
50369 }
50370 {
50371 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
50372 }
50373 {
50374 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
50375 }
50376 {
50377 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
50378 }
50379 {
50380 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
50381 }
50382 {
50383 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
50384 }
50385 {
50386 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
50387 }
50388 {
50389 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
50390 }
50391 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
50392 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
50393 {
50394 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
50401 }
50402
50403 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
50404
50405
50406 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
50407
50408 {
50409 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
50416 }
50417 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
50418 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
50419 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
50420 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
50421 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
50422 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
50423 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
50424 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
50425 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
50426 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
50427 {
50428 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
50429 }
50430 {
50431 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
50432 }
50433 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
50434 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
50435 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
50436 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
50437 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
50438 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
50439 {
50440 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
50441 }
50442 {
50443 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
50444 }
50445 {
50446 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
50447 }
50448 {
50449 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
50450 }
50451 {
50452 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
50453 }
50454 {
50455 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
50456 }
50457 {
50458 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
50459 }
50460 {
50461 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
50462 }
50463 {
50464 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
50465 }
50466 {
50467 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
50468 }
50469 {
50470 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
50471 }
50472 {
50473 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
50474 }
50475 {
50476 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
50477 }
50478 {
50479 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
50480 }
50481 {
50482 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
50483 }
50484 {
50485 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
50486 }
50487 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
50488 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
50489 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
50490 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
50491 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
50492 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
50493 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
50494 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
50495 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
50496 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
50497 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
50498 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
50499 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
50500 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
50501 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
50502 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
50503 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
50504 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
50505 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
50506 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
50507 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
50508 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
50509 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
50510 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
50511 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
50512 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
50513 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
50514 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
50515 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
50516 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
50517 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
50518 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
50519 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
50520 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
50521 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
50522 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
50523 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
50524 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
50525 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
50526 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
50527 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
50528 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
50529 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
50530 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
50531 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
50532 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
50533 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
50534 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
50535 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
50536 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
50537 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
50538 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
50539 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
50540 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
50541 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
50542 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
50543 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
50544 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
50545 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
50546 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
50547 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
50548 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
50549 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
50550 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
50551 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
50552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
50553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
50554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
50555 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
50556 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
50557 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
50558 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
50559 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
50560 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
50561 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
50562 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
50563 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
50564 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
50565 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
50566 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50567 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50568 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50569 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50570 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50571 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50572 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50573 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50574 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50575 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50576 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50577 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50578 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50579 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50580 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50581 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50582 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50583 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50584 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50585 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50586 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50587 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50588 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50589 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50590 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50591 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50592 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50593 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50594 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50595 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50596 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50597 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50598 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50599 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50600 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50601 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50602 {
50603 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50604 }
50605 {
50606 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50607 }
50608 {
50609 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50610 }
50611 {
50612 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50613 }
50614 {
50615 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50616 }
50617 {
50618 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50619 }
50620 {
50621 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50622 }
50623 {
50624 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50625 }
50626 {
50627 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50628 }
50629 {
50630 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50631 }
50632 {
50633 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50634 }
50635 {
50636 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50637 }
50638 {
50639 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50640 }
50641 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50642 {
50643 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50659 }
50660 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50661 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50662 {
50663 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50664 }
50665 {
50666 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50667 }
50668 {
50669 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50670 }
50671 {
50672 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50673 }
50674 {
50675 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50676 }
50677 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50678 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50679 {
50680 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50681 }
50682 {
50683 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50684 }
50685 {
50686 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50687 }
50688 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50689 {
50690 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50691 }
50692 {
50693 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50694 }
50695 {
50696 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50697 }
50698 {
50699 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50700 }
50701 {
50702 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50703 }
50704 {
50705 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50706 }
50707 {
50708 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50709 }
50710 {
50711 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50712 }
50713 {
50714 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50715 }
50716 {
50717 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50718 }
50719 {
50720 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50721 }
50722 {
50723 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50724 }
50725 {
50726 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50727 }
50728 {
50729 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50730 }
50731 {
50732 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50733 }
50734 {
50735 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50736 }
50737 {
50738 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50739 }
50740 {
50741 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50742 }
50743 {
50744 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50745 }
50746
50747 // Initialize threading, some globals and such
50748 __wxPyPreStart(d);
50749
50750
50751 // Although these are defined in __version__ they need to be here too so
50752 // that an assert can be done to ensure that the wxPython and the wxWindows
50753 // versions match.
50754 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50755 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50756 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50757
50758 }
50759
wxWidgets (Impactor)