]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Updated Italian translation.
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479
2480 #include <wx/quantize.h>
2481
2482 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2483 return wxQuantize::Quantize(src, dest,
2484 //NULL, // palette
2485 desiredNoColours,
2486 NULL, // eightBitData
2487 flags);
2488 }
2489 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2490 if (PyCallable_Check(func)) {
2491 self->Connect(id, lastId, eventType,
2492 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2493 new wxPyCallback(func));
2494 }
2495 else if (func == Py_None) {
2496 self->Disconnect(id, lastId, eventType,
2497 (wxObjectEventFunction)
2498 &wxPyCallback::EventThunker);
2499 }
2500 else {
2501 wxPyBLOCK_THREADS(
2502 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2503 }
2504 }
2505 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2506 return self->Disconnect(id, lastId, eventType,
2507 (wxObjectEventFunction)
2508 &wxPyCallback::EventThunker);
2509 }
2510 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2511 if (_self && _self != Py_None) {
2512 self->SetClientObject(new wxPyOORClientData(_self, incref));
2513 }
2514 else {
2515 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2516 if (data) {
2517 self->SetClientObject(NULL); // This will delete it too
2518 }
2519 }
2520 }
2521
2522 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2523 #if wxUSE_UNICODE
2524 return self->GetUnicodeKey();
2525 #else
2526 return 0;
2527 #endif
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540
2541 #if UINT_MAX != ULONG_MAX
2542 SWIGINTERN int
2543 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2544 {
2545 const char* errmsg = val ? "unsigned int" : (char*)0;
2546 unsigned long v;
2547 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2548 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2549 if (val) *val = (unsigned int)(v);
2550 return 1;
2551 }
2552 } else {
2553 PyErr_Clear();
2554 }
2555 if (val) {
2556 SWIG_type_error(errmsg, obj);
2557 }
2558 return 0;
2559 }
2560 #else
2561 SWIGINTERNSHORT unsigned int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2565 }
2566 #endif
2567
2568
2569 SWIGINTERNSHORT unsigned int
2570 SWIG_As_unsigned_SS_int(PyObject* obj)
2571 {
2572 unsigned int v;
2573 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2574 /*
2575 this is needed to make valgrind/purify happier.
2576 */
2577 memset((void*)&v, 0, sizeof(unsigned int));
2578 }
2579 return v;
2580 }
2581
2582
2583 SWIGINTERNSHORT int
2584 SWIG_Check_unsigned_SS_int(PyObject* obj)
2585 {
2586 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2587 }
2588
2589 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2590 self->m_size = size;
2591 }
2592 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2593 int count = self->GetNumberOfFiles();
2594 wxString* files = self->GetFiles();
2595 PyObject* list = PyList_New(count);
2596
2597 if (!list) {
2598 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2599 return NULL;
2600 }
2601
2602 for (int i=0; i<count; i++) {
2603 PyList_SetItem(list, i, wx2PyString(files[i]));
2604 }
2605 return list;
2606 }
2607
2608
2609 static wxPyApp *new_wxPyApp(){
2610 wxPythonApp = new wxPyApp();
2611 return wxPythonApp;
2612 }
2613
2614 void wxApp_CleanUp() {
2615 __wxPyCleanup();
2616 }
2617
2618
2619 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2620
2621
2622 SWIGINTERNSHORT int
2623 SWIG_AsCharPtr(PyObject *obj, char **val)
2624 {
2625 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2626 return 1;
2627 }
2628 if (val) {
2629 PyErr_Clear();
2630 SWIG_type_error("char *", obj);
2631 }
2632 return 0;
2633 }
2634
2635
2636 SWIGINTERN PyObject *
2637 SWIG_FromCharPtr(const char* cptr)
2638 {
2639 if (cptr) {
2640 size_t size = strlen(cptr);
2641 if (size > INT_MAX) {
2642 return SWIG_NewPointerObj((char*)(cptr),
2643 SWIG_TypeQuery("char *"), 0);
2644 } else {
2645 if (size != 0) {
2646 return PyString_FromStringAndSize(cptr, size);
2647 } else {
2648 return PyString_FromString(cptr);
2649 }
2650 }
2651 }
2652 Py_INCREF(Py_None);
2653 return Py_None;
2654 }
2655
2656
2657 #ifdef __WXMAC__
2658
2659 // A dummy class that raises an exception if used...
2660 class wxEventLoop
2661 {
2662 public:
2663 wxEventLoop() { wxPyRaiseNotImplemented(); }
2664 int Run() { return 0; }
2665 void Exit(int rc = 0) {}
2666 bool Pending() const { return false; }
2667 bool Dispatch() { return false; }
2668 bool IsRunning() const { return false; }
2669 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2670 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2671 };
2672
2673 #else
2674
2675 #include <wx/evtloop.h>
2676
2677 #endif
2678
2679
2680
2681 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2682 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2683 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2684 static PyObject *wxWindow_GetChildren(wxWindow *self){
2685 wxWindowList& list = self->GetChildren();
2686 return wxPy_ConvertList(&list);
2687 }
2688 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2689 #if wxUSE_HOTKEY
2690 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2691 #else
2692 return false;
2693 #endif
2694 }
2695 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2696
2697
2698
2699 return false;
2700
2701 }
2702 static long wxWindow_GetHandle(wxWindow *self){
2703 return wxPyGetWinHandle(self);
2704 }
2705 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2706 self->AssociateHandle((WXWidget)handle);
2707 }
2708
2709 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowById(id, parent);
2711 }
2712
2713 wxWindow* wxFindWindowByName( const wxString& name,
2714 const wxWindow *parent = NULL ) {
2715 return wxWindow::FindWindowByName(name, parent);
2716 }
2717
2718 wxWindow* wxFindWindowByLabel( const wxString& label,
2719 const wxWindow *parent = NULL ) {
2720 return wxWindow::FindWindowByLabel(label, parent);
2721 }
2722
2723
2724 #ifdef __WXMSW__
2725 #include <wx/msw/private.h> // to get wxGetWindowId
2726 #endif
2727
2728
2729 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2730 #ifdef __WXMSW__
2731 WXHWND hWnd = (WXHWND)_hWnd;
2732 long id = wxGetWindowId(hWnd);
2733 wxWindow* win = new wxWindow;
2734 parent->AddChild(win);
2735 win->SetEventHandler(win);
2736 win->SetHWND(hWnd);
2737 win->SetId(id);
2738 win->SubclassWin(hWnd);
2739 win->AdoptAttributesFromHWND();
2740 win->SetupColours();
2741 return win;
2742 #else
2743 wxPyRaiseNotImplemented();
2744 return NULL;
2745 #endif
2746 }
2747
2748
2749 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2750 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2751 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2752
2753 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2754
2755 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2756 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2757 wxMenuItemList& list = self->GetMenuItems();
2758 return wxPy_ConvertList(&list);
2759 }
2760 static const wxString wxPyControlNameStr(wxControlNameStr);
2761 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2762 if (clientData) {
2763 wxPyClientData* data = new wxPyClientData(clientData);
2764 return self->Append(item, data);
2765 } else
2766 return self->Append(item);
2767 }
2768 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2769 if (clientData) {
2770 wxPyClientData* data = new wxPyClientData(clientData);
2771 return self->Insert(item, pos, data);
2772 } else
2773 return self->Insert(item, pos);
2774 }
2775 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2776 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2777 if (data) {
2778 Py_INCREF(data->m_obj);
2779 return data->m_obj;
2780 } else {
2781 Py_INCREF(Py_None);
2782 return Py_None;
2783 }
2784 }
2785 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2786 wxPyClientData* data = new wxPyClientData(clientData);
2787 self->SetClientObject(n, data);
2788 }
2789
2790
2791 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2792 wxPyUserData* data = NULL;
2793 if ( userData ) {
2794 bool blocked = wxPyBeginBlockThreads();
2795 data = new wxPyUserData(userData);
2796 wxPyEndBlockThreads(blocked);
2797 }
2798 return new wxSizerItem(window, proportion, flag, border, data);
2799 }
2800 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2801 wxPyUserData* data = NULL;
2802 if ( userData ) {
2803 bool blocked = wxPyBeginBlockThreads();
2804 data = new wxPyUserData(userData);
2805 wxPyEndBlockThreads(blocked);
2806 }
2807 return new wxSizerItem(width, height, proportion, flag, border, data);
2808 }
2809 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2810 wxPyUserData* data = NULL;
2811 if ( userData ) {
2812 bool blocked = wxPyBeginBlockThreads();
2813 data = new wxPyUserData(userData);
2814 wxPyEndBlockThreads(blocked);
2815 }
2816 return new wxSizerItem(sizer, proportion, flag, border, data);
2817 }
2818
2819 #include <float.h>
2820 SWIGINTERN int
2821 SWIG_CheckDoubleInRange(double value, double min_value,
2822 double max_value, const char* errmsg)
2823 {
2824 if (value < min_value) {
2825 if (errmsg) {
2826 PyErr_Format(PyExc_OverflowError,
2827 "value %g is less than %s minimum %g",
2828 value, errmsg, min_value);
2829 }
2830 return 0;
2831 } else if (value > max_value) {
2832 if (errmsg) {
2833 PyErr_Format(PyExc_OverflowError,
2834 "value %g is greater than %s maximum %g",
2835 value, errmsg, max_value);
2836 }
2837 return 0;
2838 }
2839 return 1;
2840 }
2841
2842
2843 SWIGINTERN int
2844 SWIG_AsVal_float(PyObject *obj, float *val)
2845 {
2846 const char* errmsg = val ? "float" : (char*)0;
2847 double v;
2848 if (SWIG_AsVal_double(obj, &v)) {
2849 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2850 if (val) *val = (float)(v);
2851 return 1;
2852 } else {
2853 return 0;
2854 }
2855 } else {
2856 PyErr_Clear();
2857 }
2858 if (val) {
2859 SWIG_type_error(errmsg, obj);
2860 }
2861 return 0;
2862 }
2863
2864
2865 SWIGINTERNSHORT float
2866 SWIG_As_float(PyObject* obj)
2867 {
2868 float v;
2869 if (!SWIG_AsVal_float(obj, &v)) {
2870 /*
2871 this is needed to make valgrind/purify happier.
2872 */
2873 memset((void*)&v, 0, sizeof(float));
2874 }
2875 return v;
2876 }
2877
2878
2879 SWIGINTERNSHORT int
2880 SWIG_Check_float(PyObject* obj)
2881 {
2882 return SWIG_AsVal_float(obj, (float*)0);
2883 }
2884
2885
2886 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2887 #define SWIG_From_float PyFloat_FromDouble
2888 /*@@*/
2889
2890 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2891 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2892 if (data) {
2893 Py_INCREF(data->m_obj);
2894 return data->m_obj;
2895 } else {
2896 Py_INCREF(Py_None);
2897 return Py_None;
2898 }
2899 }
2900
2901 // Figure out the type of the sizer item
2902
2903 struct wxPySizerItemInfo {
2904 wxPySizerItemInfo()
2905 : window(NULL), sizer(NULL), gotSize(false),
2906 size(wxDefaultSize), gotPos(false), pos(-1)
2907 {}
2908
2909 wxWindow* window;
2910 wxSizer* sizer;
2911 bool gotSize;
2912 wxSize size;
2913 bool gotPos;
2914 int pos;
2915 };
2916
2917 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2918
2919 wxPySizerItemInfo info;
2920 wxSize size;
2921 wxSize* sizePtr = &size;
2922
2923 // Find out what the type of the item is
2924 // try wxWindow
2925 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2926 PyErr_Clear();
2927 info.window = NULL;
2928
2929 // try wxSizer
2930 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2931 PyErr_Clear();
2932 info.sizer = NULL;
2933
2934 // try wxSize or (w,h)
2935 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2936 info.size = *sizePtr;
2937 info.gotSize = true;
2938 }
2939
2940 // or a single int
2941 if (checkIdx && PyInt_Check(item)) {
2942 info.pos = PyInt_AsLong(item);
2943 info.gotPos = true;
2944 }
2945 }
2946 }
2947
2948 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2949 // no expected type, figure out what kind of error message to generate
2950 if ( !checkSize && !checkIdx )
2951 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2952 else if ( checkSize && !checkIdx )
2953 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2954 else if ( !checkSize && checkIdx)
2955 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2956 else
2957 // can this one happen?
2958 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2959 }
2960
2961 return info;
2962 }
2963
2964 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2965 if (!self->GetClientObject())
2966 self->SetClientObject(new wxPyOORClientData(_self));
2967 }
2968 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2969
2970 wxPyUserData* data = NULL;
2971 bool blocked = wxPyBeginBlockThreads();
2972 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2973 if ( userData && (info.window || info.sizer || info.gotSize) )
2974 data = new wxPyUserData(userData);
2975 wxPyEndBlockThreads(blocked);
2976
2977 // Now call the real Add method if a valid item type was found
2978 if ( info.window )
2979 return self->Add(info.window, proportion, flag, border, data);
2980 else if ( info.sizer )
2981 return self->Add(info.sizer, proportion, flag, border, data);
2982 else if (info.gotSize)
2983 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2984 proportion, flag, border, data);
2985 else
2986 return NULL;
2987 }
2988 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2989
2990 wxPyUserData* data = NULL;
2991 bool blocked = wxPyBeginBlockThreads();
2992 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2993 if ( userData && (info.window || info.sizer || info.gotSize) )
2994 data = new wxPyUserData(userData);
2995 wxPyEndBlockThreads(blocked);
2996
2997 // Now call the real Insert method if a valid item type was found
2998 if ( info.window )
2999 return self->Insert(before, info.window, proportion, flag, border, data);
3000 else if ( info.sizer )
3001 return self->Insert(before, info.sizer, proportion, flag, border, data);
3002 else if (info.gotSize)
3003 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3004 proportion, flag, border, data);
3005 else
3006 return NULL;
3007 }
3008 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3009
3010 wxPyUserData* data = NULL;
3011 bool blocked = wxPyBeginBlockThreads();
3012 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3013 if ( userData && (info.window || info.sizer || info.gotSize) )
3014 data = new wxPyUserData(userData);
3015 wxPyEndBlockThreads(blocked);
3016
3017 // Now call the real Prepend method if a valid item type was found
3018 if ( info.window )
3019 return self->Prepend(info.window, proportion, flag, border, data);
3020 else if ( info.sizer )
3021 return self->Prepend(info.sizer, proportion, flag, border, data);
3022 else if (info.gotSize)
3023 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3024 proportion, flag, border, data);
3025 else
3026 return NULL;
3027 }
3028 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3029 bool blocked = wxPyBeginBlockThreads();
3030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3031 wxPyEndBlockThreads(blocked);
3032 if ( info.window )
3033 return self->Remove(info.window);
3034 else if ( info.sizer )
3035 return self->Remove(info.sizer);
3036 else if ( info.gotPos )
3037 return self->Remove(info.pos);
3038 else
3039 return false;
3040 }
3041 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3042 bool blocked = wxPyBeginBlockThreads();
3043 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3044 wxPyEndBlockThreads(blocked);
3045 if ( info.window )
3046 return self->Detach(info.window);
3047 else if ( info.sizer )
3048 return self->Detach(info.sizer);
3049 else if ( info.gotPos )
3050 return self->Detach(info.pos);
3051 else
3052 return false;
3053 }
3054 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3055 bool blocked = wxPyBeginBlockThreads();
3056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3057 wxPyEndBlockThreads(blocked);
3058 if ( info.window )
3059 return self->GetItem(info.window);
3060 else if ( info.sizer )
3061 return self->GetItem(info.sizer);
3062 else if ( info.gotPos )
3063 return self->GetItem(info.pos);
3064 else
3065 return NULL;
3066 }
3067 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3068 bool blocked = wxPyBeginBlockThreads();
3069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3070 wxPyEndBlockThreads(blocked);
3071 if ( info.window )
3072 self->SetItemMinSize(info.window, size);
3073 else if ( info.sizer )
3074 self->SetItemMinSize(info.sizer, size);
3075 else if ( info.gotPos )
3076 self->SetItemMinSize(info.pos, size);
3077 }
3078 static PyObject *wxSizer_GetChildren(wxSizer *self){
3079 wxSizerItemList& list = self->GetChildren();
3080 return wxPy_ConvertList(&list);
3081 }
3082 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3083 bool blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->Show(info.window, show, recursive);
3088 else if ( info.sizer )
3089 return self->Show(info.sizer, show, recursive);
3090 else if ( info.gotPos )
3091 return self->Show(info.pos, show);
3092 else
3093 return false;
3094 }
3095 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3096 bool blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3098 wxPyEndBlockThreads(blocked);
3099 if ( info.window )
3100 return self->IsShown(info.window);
3101 else if ( info.sizer )
3102 return self->IsShown(info.sizer);
3103 else if ( info.gotPos )
3104 return self->IsShown(info.pos);
3105 else
3106 return false;
3107 }
3108
3109 // See pyclasses.h
3110 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3111 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3112 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3113
3114
3115
3116
3117 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3118 {
3119 if (source == Py_None) {
3120 **obj = wxGBPosition(-1,-1);
3121 return true;
3122 }
3123 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3124 }
3125
3126 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3127 {
3128 if (source == Py_None) {
3129 **obj = wxGBSpan(-1,-1);
3130 return true;
3131 }
3132 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3133 }
3134
3135
3136 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3137 self->SetRow(row);
3138 self->SetCol(col);
3139 }
3140 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3141 bool blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3144 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3149 self->SetRowspan(rowspan);
3150 self->SetColspan(colspan);
3151 }
3152 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3153 bool blocked = wxPyBeginBlockThreads();
3154 PyObject* tup = PyTuple_New(2);
3155 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3156 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3157 wxPyEndBlockThreads(blocked);
3158 return tup;
3159 }
3160 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3161 wxPyUserData* data = NULL;
3162 if ( userData ) {
3163 bool blocked = wxPyBeginBlockThreads();
3164 data = new wxPyUserData(userData);
3165 wxPyEndBlockThreads(blocked);
3166 }
3167 return new wxGBSizerItem(window, pos, span, flag, border, data);
3168 }
3169 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3170 wxPyUserData* data = NULL;
3171 if ( userData ) {
3172 bool blocked = wxPyBeginBlockThreads();
3173 data = new wxPyUserData(userData);
3174 wxPyEndBlockThreads(blocked);
3175 }
3176 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3177 }
3178 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3179 wxPyUserData* data = NULL;
3180 if ( userData ) {
3181 bool blocked = wxPyBeginBlockThreads();
3182 data = new wxPyUserData(userData);
3183 wxPyEndBlockThreads(blocked);
3184 }
3185 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3186 }
3187 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3188 int row, col;
3189 self->GetEndPos(row, col);
3190 return wxGBPosition(row, col);
3191 }
3192 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3193
3194 wxPyUserData* data = NULL;
3195 bool blocked = wxPyBeginBlockThreads();
3196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3197 if ( userData && (info.window || info.sizer || info.gotSize) )
3198 data = new wxPyUserData(userData);
3199 wxPyEndBlockThreads(blocked);
3200
3201 // Now call the real Add method if a valid item type was found
3202 if ( info.window )
3203 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3204 else if ( info.sizer )
3205 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3206 else if (info.gotSize)
3207 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3208 pos, span, flag, border, data);
3209 return NULL;
3210 }
3211
3212
3213 #ifdef __cplusplus
3214 extern "C" {
3215 #endif
3216 static int _wrap_EmptyString_set(PyObject *) {
3217 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3218 return 1;
3219 }
3220
3221
3222 static PyObject *_wrap_EmptyString_get(void) {
3223 PyObject *pyobj;
3224
3225 {
3226 #if wxUSE_UNICODE
3227 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3228 #else
3229 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3230 #endif
3231 }
3232 return pyobj;
3233 }
3234
3235
3236 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3237 PyObject *resultobj;
3238 wxObject *arg1 = (wxObject *) 0 ;
3239 wxString result;
3240 PyObject * obj0 = 0 ;
3241 char *kwnames[] = {
3242 (char *) "self", NULL
3243 };
3244
3245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3247 if (SWIG_arg_fail(1)) SWIG_fail;
3248 {
3249 PyThreadState* __tstate = wxPyBeginAllowThreads();
3250 result = wxObject_GetClassName(arg1);
3251
3252 wxPyEndAllowThreads(__tstate);
3253 if (PyErr_Occurred()) SWIG_fail;
3254 }
3255 {
3256 #if wxUSE_UNICODE
3257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3258 #else
3259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3260 #endif
3261 }
3262 return resultobj;
3263 fail:
3264 return NULL;
3265 }
3266
3267
3268 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3269 PyObject *resultobj;
3270 wxObject *arg1 = (wxObject *) 0 ;
3271 PyObject * obj0 = 0 ;
3272 char *kwnames[] = {
3273 (char *) "self", NULL
3274 };
3275
3276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3278 if (SWIG_arg_fail(1)) SWIG_fail;
3279 {
3280 PyThreadState* __tstate = wxPyBeginAllowThreads();
3281 wxObject_Destroy(arg1);
3282
3283 wxPyEndAllowThreads(__tstate);
3284 if (PyErr_Occurred()) SWIG_fail;
3285 }
3286 Py_INCREF(Py_None); resultobj = Py_None;
3287 return resultobj;
3288 fail:
3289 return NULL;
3290 }
3291
3292
3293 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3294 PyObject *obj;
3295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3296 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3297 Py_INCREF(obj);
3298 return Py_BuildValue((char *)"");
3299 }
3300 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3301 PyObject *resultobj;
3302 wxSize *arg1 = (wxSize *) 0 ;
3303 int arg2 ;
3304 PyObject * obj0 = 0 ;
3305 PyObject * obj1 = 0 ;
3306 char *kwnames[] = {
3307 (char *) "self",(char *) "x", NULL
3308 };
3309
3310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3312 if (SWIG_arg_fail(1)) SWIG_fail;
3313 {
3314 arg2 = (int)(SWIG_As_int(obj1));
3315 if (SWIG_arg_fail(2)) SWIG_fail;
3316 }
3317 if (arg1) (arg1)->x = arg2;
3318
3319 Py_INCREF(Py_None); resultobj = Py_None;
3320 return resultobj;
3321 fail:
3322 return NULL;
3323 }
3324
3325
3326 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3327 PyObject *resultobj;
3328 wxSize *arg1 = (wxSize *) 0 ;
3329 int result;
3330 PyObject * obj0 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "self", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3337 if (SWIG_arg_fail(1)) SWIG_fail;
3338 result = (int) ((arg1)->x);
3339
3340 {
3341 resultobj = SWIG_From_int((int)(result));
3342 }
3343 return resultobj;
3344 fail:
3345 return NULL;
3346 }
3347
3348
3349 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3350 PyObject *resultobj;
3351 wxSize *arg1 = (wxSize *) 0 ;
3352 int arg2 ;
3353 PyObject * obj0 = 0 ;
3354 PyObject * obj1 = 0 ;
3355 char *kwnames[] = {
3356 (char *) "self",(char *) "y", NULL
3357 };
3358
3359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3361 if (SWIG_arg_fail(1)) SWIG_fail;
3362 {
3363 arg2 = (int)(SWIG_As_int(obj1));
3364 if (SWIG_arg_fail(2)) SWIG_fail;
3365 }
3366 if (arg1) (arg1)->y = arg2;
3367
3368 Py_INCREF(Py_None); resultobj = Py_None;
3369 return resultobj;
3370 fail:
3371 return NULL;
3372 }
3373
3374
3375 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3376 PyObject *resultobj;
3377 wxSize *arg1 = (wxSize *) 0 ;
3378 int result;
3379 PyObject * obj0 = 0 ;
3380 char *kwnames[] = {
3381 (char *) "self", NULL
3382 };
3383
3384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3386 if (SWIG_arg_fail(1)) SWIG_fail;
3387 result = (int) ((arg1)->y);
3388
3389 {
3390 resultobj = SWIG_From_int((int)(result));
3391 }
3392 return resultobj;
3393 fail:
3394 return NULL;
3395 }
3396
3397
3398 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3399 PyObject *resultobj;
3400 int arg1 = (int) 0 ;
3401 int arg2 = (int) 0 ;
3402 wxSize *result;
3403 PyObject * obj0 = 0 ;
3404 PyObject * obj1 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "w",(char *) "h", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3410 if (obj0) {
3411 {
3412 arg1 = (int)(SWIG_As_int(obj0));
3413 if (SWIG_arg_fail(1)) SWIG_fail;
3414 }
3415 }
3416 if (obj1) {
3417 {
3418 arg2 = (int)(SWIG_As_int(obj1));
3419 if (SWIG_arg_fail(2)) SWIG_fail;
3420 }
3421 }
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 result = (wxSize *)new wxSize(arg1,arg2);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3430 return resultobj;
3431 fail:
3432 return NULL;
3433 }
3434
3435
3436 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3437 PyObject *resultobj;
3438 wxSize *arg1 = (wxSize *) 0 ;
3439 PyObject * obj0 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 PyThreadState* __tstate = wxPyBeginAllowThreads();
3449 delete arg1;
3450
3451 wxPyEndAllowThreads(__tstate);
3452 if (PyErr_Occurred()) SWIG_fail;
3453 }
3454 Py_INCREF(Py_None); resultobj = Py_None;
3455 return resultobj;
3456 fail:
3457 return NULL;
3458 }
3459
3460
3461 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3462 PyObject *resultobj;
3463 wxSize *arg1 = (wxSize *) 0 ;
3464 wxSize *arg2 = 0 ;
3465 bool result;
3466 wxSize temp2 ;
3467 PyObject * obj0 = 0 ;
3468 PyObject * obj1 = 0 ;
3469 char *kwnames[] = {
3470 (char *) "self",(char *) "sz", NULL
3471 };
3472
3473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3475 if (SWIG_arg_fail(1)) SWIG_fail;
3476 {
3477 arg2 = &temp2;
3478 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3479 }
3480 {
3481 PyThreadState* __tstate = wxPyBeginAllowThreads();
3482 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3483
3484 wxPyEndAllowThreads(__tstate);
3485 if (PyErr_Occurred()) SWIG_fail;
3486 }
3487 {
3488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3489 }
3490 return resultobj;
3491 fail:
3492 return NULL;
3493 }
3494
3495
3496 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3497 PyObject *resultobj;
3498 wxSize *arg1 = (wxSize *) 0 ;
3499 wxSize *arg2 = 0 ;
3500 bool result;
3501 wxSize temp2 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self",(char *) "sz", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 arg2 = &temp2;
3513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 return resultobj;
3526 fail:
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 wxSize *arg1 = (wxSize *) 0 ;
3534 wxSize *arg2 = 0 ;
3535 wxSize result;
3536 wxSize temp2 ;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "self",(char *) "sz", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3545 if (SWIG_arg_fail(1)) SWIG_fail;
3546 {
3547 arg2 = &temp2;
3548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (arg1)->operator +((wxSize const &)*arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 wxSize * resultptr;
3559 resultptr = new wxSize((wxSize &)(result));
3560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3561 }
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 wxSize *arg1 = (wxSize *) 0 ;
3571 wxSize *arg2 = 0 ;
3572 wxSize result;
3573 wxSize temp2 ;
3574 PyObject * obj0 = 0 ;
3575 PyObject * obj1 = 0 ;
3576 char *kwnames[] = {
3577 (char *) "self",(char *) "sz", NULL
3578 };
3579
3580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3582 if (SWIG_arg_fail(1)) SWIG_fail;
3583 {
3584 arg2 = &temp2;
3585 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3586 }
3587 {
3588 PyThreadState* __tstate = wxPyBeginAllowThreads();
3589 result = (arg1)->operator -((wxSize const &)*arg2);
3590
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 {
3595 wxSize * resultptr;
3596 resultptr = new wxSize((wxSize &)(result));
3597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3598 }
3599 return resultobj;
3600 fail:
3601 return NULL;
3602 }
3603
3604
3605 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3606 PyObject *resultobj;
3607 wxSize *arg1 = (wxSize *) 0 ;
3608 wxSize *arg2 = 0 ;
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_IncTo",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 (arg1)->IncTo((wxSize const &)*arg2);
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 Py_INCREF(Py_None); resultobj = Py_None;
3631 return resultobj;
3632 fail:
3633 return NULL;
3634 }
3635
3636
3637 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3638 PyObject *resultobj;
3639 wxSize *arg1 = (wxSize *) 0 ;
3640 wxSize *arg2 = 0 ;
3641 wxSize temp2 ;
3642 PyObject * obj0 = 0 ;
3643 PyObject * obj1 = 0 ;
3644 char *kwnames[] = {
3645 (char *) "self",(char *) "sz", NULL
3646 };
3647
3648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3650 if (SWIG_arg_fail(1)) SWIG_fail;
3651 {
3652 arg2 = &temp2;
3653 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3654 }
3655 {
3656 PyThreadState* __tstate = wxPyBeginAllowThreads();
3657 (arg1)->DecTo((wxSize const &)*arg2);
3658
3659 wxPyEndAllowThreads(__tstate);
3660 if (PyErr_Occurred()) SWIG_fail;
3661 }
3662 Py_INCREF(Py_None); resultobj = Py_None;
3663 return resultobj;
3664 fail:
3665 return NULL;
3666 }
3667
3668
3669 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3670 PyObject *resultobj;
3671 wxSize *arg1 = (wxSize *) 0 ;
3672 int arg2 ;
3673 int arg3 ;
3674 PyObject * obj0 = 0 ;
3675 PyObject * obj1 = 0 ;
3676 PyObject * obj2 = 0 ;
3677 char *kwnames[] = {
3678 (char *) "self",(char *) "w",(char *) "h", NULL
3679 };
3680
3681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3683 if (SWIG_arg_fail(1)) SWIG_fail;
3684 {
3685 arg2 = (int)(SWIG_As_int(obj1));
3686 if (SWIG_arg_fail(2)) SWIG_fail;
3687 }
3688 {
3689 arg3 = (int)(SWIG_As_int(obj2));
3690 if (SWIG_arg_fail(3)) SWIG_fail;
3691 }
3692 {
3693 PyThreadState* __tstate = wxPyBeginAllowThreads();
3694 (arg1)->Set(arg2,arg3);
3695
3696 wxPyEndAllowThreads(__tstate);
3697 if (PyErr_Occurred()) SWIG_fail;
3698 }
3699 Py_INCREF(Py_None); resultobj = Py_None;
3700 return resultobj;
3701 fail:
3702 return NULL;
3703 }
3704
3705
3706 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3707 PyObject *resultobj;
3708 wxSize *arg1 = (wxSize *) 0 ;
3709 int arg2 ;
3710 PyObject * obj0 = 0 ;
3711 PyObject * obj1 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self",(char *) "w", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 arg2 = (int)(SWIG_As_int(obj1));
3721 if (SWIG_arg_fail(2)) SWIG_fail;
3722 }
3723 {
3724 PyThreadState* __tstate = wxPyBeginAllowThreads();
3725 (arg1)->SetWidth(arg2);
3726
3727 wxPyEndAllowThreads(__tstate);
3728 if (PyErr_Occurred()) SWIG_fail;
3729 }
3730 Py_INCREF(Py_None); resultobj = Py_None;
3731 return resultobj;
3732 fail:
3733 return NULL;
3734 }
3735
3736
3737 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3738 PyObject *resultobj;
3739 wxSize *arg1 = (wxSize *) 0 ;
3740 int arg2 ;
3741 PyObject * obj0 = 0 ;
3742 PyObject * obj1 = 0 ;
3743 char *kwnames[] = {
3744 (char *) "self",(char *) "h", NULL
3745 };
3746
3747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3749 if (SWIG_arg_fail(1)) SWIG_fail;
3750 {
3751 arg2 = (int)(SWIG_As_int(obj1));
3752 if (SWIG_arg_fail(2)) SWIG_fail;
3753 }
3754 {
3755 PyThreadState* __tstate = wxPyBeginAllowThreads();
3756 (arg1)->SetHeight(arg2);
3757
3758 wxPyEndAllowThreads(__tstate);
3759 if (PyErr_Occurred()) SWIG_fail;
3760 }
3761 Py_INCREF(Py_None); resultobj = Py_None;
3762 return resultobj;
3763 fail:
3764 return NULL;
3765 }
3766
3767
3768 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3769 PyObject *resultobj;
3770 wxSize *arg1 = (wxSize *) 0 ;
3771 int result;
3772 PyObject * obj0 = 0 ;
3773 char *kwnames[] = {
3774 (char *) "self", NULL
3775 };
3776
3777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3779 if (SWIG_arg_fail(1)) SWIG_fail;
3780 {
3781 PyThreadState* __tstate = wxPyBeginAllowThreads();
3782 result = (int)((wxSize const *)arg1)->GetWidth();
3783
3784 wxPyEndAllowThreads(__tstate);
3785 if (PyErr_Occurred()) SWIG_fail;
3786 }
3787 {
3788 resultobj = SWIG_From_int((int)(result));
3789 }
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 wxSize *arg1 = (wxSize *) 0 ;
3799 int result;
3800 PyObject * obj0 = 0 ;
3801 char *kwnames[] = {
3802 (char *) "self", NULL
3803 };
3804
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3807 if (SWIG_arg_fail(1)) SWIG_fail;
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (int)((wxSize const *)arg1)->GetHeight();
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_int((int)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 wxSize *arg1 = (wxSize *) 0 ;
3827 bool result;
3828 PyObject * obj0 = 0 ;
3829 char *kwnames[] = {
3830 (char *) "self", NULL
3831 };
3832
3833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3835 if (SWIG_arg_fail(1)) SWIG_fail;
3836 {
3837 PyThreadState* __tstate = wxPyBeginAllowThreads();
3838 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3839
3840 wxPyEndAllowThreads(__tstate);
3841 if (PyErr_Occurred()) SWIG_fail;
3842 }
3843 {
3844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3845 }
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj;
3854 wxSize *arg1 = (wxSize *) 0 ;
3855 wxSize *arg2 = 0 ;
3856 wxSize temp2 ;
3857 PyObject * obj0 = 0 ;
3858 PyObject * obj1 = 0 ;
3859 char *kwnames[] = {
3860 (char *) "self",(char *) "size", NULL
3861 };
3862
3863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3865 if (SWIG_arg_fail(1)) SWIG_fail;
3866 {
3867 arg2 = &temp2;
3868 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3869 }
3870 {
3871 PyThreadState* __tstate = wxPyBeginAllowThreads();
3872 (arg1)->SetDefaults((wxSize const &)*arg2);
3873
3874 wxPyEndAllowThreads(__tstate);
3875 if (PyErr_Occurred()) SWIG_fail;
3876 }
3877 Py_INCREF(Py_None); resultobj = Py_None;
3878 return resultobj;
3879 fail:
3880 return NULL;
3881 }
3882
3883
3884 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3885 PyObject *resultobj;
3886 wxSize *arg1 = (wxSize *) 0 ;
3887 PyObject *result;
3888 PyObject * obj0 = 0 ;
3889 char *kwnames[] = {
3890 (char *) "self", NULL
3891 };
3892
3893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3895 if (SWIG_arg_fail(1)) SWIG_fail;
3896 {
3897 PyThreadState* __tstate = wxPyBeginAllowThreads();
3898 result = (PyObject *)wxSize_Get(arg1);
3899
3900 wxPyEndAllowThreads(__tstate);
3901 if (PyErr_Occurred()) SWIG_fail;
3902 }
3903 resultobj = result;
3904 return resultobj;
3905 fail:
3906 return NULL;
3907 }
3908
3909
3910 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3911 PyObject *obj;
3912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3913 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3914 Py_INCREF(obj);
3915 return Py_BuildValue((char *)"");
3916 }
3917 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3918 PyObject *resultobj;
3919 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3920 double arg2 ;
3921 PyObject * obj0 = 0 ;
3922 PyObject * obj1 = 0 ;
3923 char *kwnames[] = {
3924 (char *) "self",(char *) "x", NULL
3925 };
3926
3927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3929 if (SWIG_arg_fail(1)) SWIG_fail;
3930 {
3931 arg2 = (double)(SWIG_As_double(obj1));
3932 if (SWIG_arg_fail(2)) SWIG_fail;
3933 }
3934 if (arg1) (arg1)->x = arg2;
3935
3936 Py_INCREF(Py_None); resultobj = Py_None;
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3944 PyObject *resultobj;
3945 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3946 double result;
3947 PyObject * obj0 = 0 ;
3948 char *kwnames[] = {
3949 (char *) "self", NULL
3950 };
3951
3952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3954 if (SWIG_arg_fail(1)) SWIG_fail;
3955 result = (double) ((arg1)->x);
3956
3957 {
3958 resultobj = SWIG_From_double((double)(result));
3959 }
3960 return resultobj;
3961 fail:
3962 return NULL;
3963 }
3964
3965
3966 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3967 PyObject *resultobj;
3968 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3969 double arg2 ;
3970 PyObject * obj0 = 0 ;
3971 PyObject * obj1 = 0 ;
3972 char *kwnames[] = {
3973 (char *) "self",(char *) "y", NULL
3974 };
3975
3976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3978 if (SWIG_arg_fail(1)) SWIG_fail;
3979 {
3980 arg2 = (double)(SWIG_As_double(obj1));
3981 if (SWIG_arg_fail(2)) SWIG_fail;
3982 }
3983 if (arg1) (arg1)->y = arg2;
3984
3985 Py_INCREF(Py_None); resultobj = Py_None;
3986 return resultobj;
3987 fail:
3988 return NULL;
3989 }
3990
3991
3992 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3993 PyObject *resultobj;
3994 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3995 double result;
3996 PyObject * obj0 = 0 ;
3997 char *kwnames[] = {
3998 (char *) "self", NULL
3999 };
4000
4001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4003 if (SWIG_arg_fail(1)) SWIG_fail;
4004 result = (double) ((arg1)->y);
4005
4006 {
4007 resultobj = SWIG_From_double((double)(result));
4008 }
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj;
4017 double arg1 = (double) 0.0 ;
4018 double arg2 = (double) 0.0 ;
4019 wxRealPoint *result;
4020 PyObject * obj0 = 0 ;
4021 PyObject * obj1 = 0 ;
4022 char *kwnames[] = {
4023 (char *) "x",(char *) "y", NULL
4024 };
4025
4026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4027 if (obj0) {
4028 {
4029 arg1 = (double)(SWIG_As_double(obj0));
4030 if (SWIG_arg_fail(1)) SWIG_fail;
4031 }
4032 }
4033 if (obj1) {
4034 {
4035 arg2 = (double)(SWIG_As_double(obj1));
4036 if (SWIG_arg_fail(2)) SWIG_fail;
4037 }
4038 }
4039 {
4040 PyThreadState* __tstate = wxPyBeginAllowThreads();
4041 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4042
4043 wxPyEndAllowThreads(__tstate);
4044 if (PyErr_Occurred()) SWIG_fail;
4045 }
4046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4047 return resultobj;
4048 fail:
4049 return NULL;
4050 }
4051
4052
4053 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4054 PyObject *resultobj;
4055 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4056 PyObject * obj0 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "self", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4063 if (SWIG_arg_fail(1)) SWIG_fail;
4064 {
4065 PyThreadState* __tstate = wxPyBeginAllowThreads();
4066 delete arg1;
4067
4068 wxPyEndAllowThreads(__tstate);
4069 if (PyErr_Occurred()) SWIG_fail;
4070 }
4071 Py_INCREF(Py_None); resultobj = Py_None;
4072 return resultobj;
4073 fail:
4074 return NULL;
4075 }
4076
4077
4078 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4079 PyObject *resultobj;
4080 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4081 wxRealPoint *arg2 = 0 ;
4082 bool result;
4083 wxRealPoint temp2 ;
4084 PyObject * obj0 = 0 ;
4085 PyObject * obj1 = 0 ;
4086 char *kwnames[] = {
4087 (char *) "self",(char *) "pt", NULL
4088 };
4089
4090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4092 if (SWIG_arg_fail(1)) SWIG_fail;
4093 {
4094 arg2 = &temp2;
4095 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4096 }
4097 {
4098 PyThreadState* __tstate = wxPyBeginAllowThreads();
4099 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4100
4101 wxPyEndAllowThreads(__tstate);
4102 if (PyErr_Occurred()) SWIG_fail;
4103 }
4104 {
4105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4106 }
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4116 wxRealPoint *arg2 = 0 ;
4117 bool result;
4118 wxRealPoint temp2 ;
4119 PyObject * obj0 = 0 ;
4120 PyObject * obj1 = 0 ;
4121 char *kwnames[] = {
4122 (char *) "self",(char *) "pt", NULL
4123 };
4124
4125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 {
4129 arg2 = &temp2;
4130 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4141 }
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4151 wxRealPoint *arg2 = 0 ;
4152 wxRealPoint result;
4153 wxRealPoint temp2 ;
4154 PyObject * obj0 = 0 ;
4155 PyObject * obj1 = 0 ;
4156 char *kwnames[] = {
4157 (char *) "self",(char *) "pt", NULL
4158 };
4159
4160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 {
4164 arg2 = &temp2;
4165 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 wxRealPoint * resultptr;
4176 resultptr = new wxRealPoint((wxRealPoint &)(result));
4177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4178 }
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4188 wxRealPoint *arg2 = 0 ;
4189 wxRealPoint result;
4190 wxRealPoint temp2 ;
4191 PyObject * obj0 = 0 ;
4192 PyObject * obj1 = 0 ;
4193 char *kwnames[] = {
4194 (char *) "self",(char *) "pt", NULL
4195 };
4196
4197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4199 if (SWIG_arg_fail(1)) SWIG_fail;
4200 {
4201 arg2 = &temp2;
4202 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4203 }
4204 {
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4207
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 {
4212 wxRealPoint * resultptr;
4213 resultptr = new wxRealPoint((wxRealPoint &)(result));
4214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4215 }
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj;
4224 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4225 double arg2 ;
4226 double arg3 ;
4227 PyObject * obj0 = 0 ;
4228 PyObject * obj1 = 0 ;
4229 PyObject * obj2 = 0 ;
4230 char *kwnames[] = {
4231 (char *) "self",(char *) "x",(char *) "y", NULL
4232 };
4233
4234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4236 if (SWIG_arg_fail(1)) SWIG_fail;
4237 {
4238 arg2 = (double)(SWIG_As_double(obj1));
4239 if (SWIG_arg_fail(2)) SWIG_fail;
4240 }
4241 {
4242 arg3 = (double)(SWIG_As_double(obj2));
4243 if (SWIG_arg_fail(3)) SWIG_fail;
4244 }
4245 {
4246 PyThreadState* __tstate = wxPyBeginAllowThreads();
4247 wxRealPoint_Set(arg1,arg2,arg3);
4248
4249 wxPyEndAllowThreads(__tstate);
4250 if (PyErr_Occurred()) SWIG_fail;
4251 }
4252 Py_INCREF(Py_None); resultobj = Py_None;
4253 return resultobj;
4254 fail:
4255 return NULL;
4256 }
4257
4258
4259 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4260 PyObject *resultobj;
4261 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4262 PyObject *result;
4263 PyObject * obj0 = 0 ;
4264 char *kwnames[] = {
4265 (char *) "self", NULL
4266 };
4267
4268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4270 if (SWIG_arg_fail(1)) SWIG_fail;
4271 {
4272 PyThreadState* __tstate = wxPyBeginAllowThreads();
4273 result = (PyObject *)wxRealPoint_Get(arg1);
4274
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = result;
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4286 PyObject *obj;
4287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4288 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4289 Py_INCREF(obj);
4290 return Py_BuildValue((char *)"");
4291 }
4292 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4293 PyObject *resultobj;
4294 wxPoint *arg1 = (wxPoint *) 0 ;
4295 int arg2 ;
4296 PyObject * obj0 = 0 ;
4297 PyObject * obj1 = 0 ;
4298 char *kwnames[] = {
4299 (char *) "self",(char *) "x", NULL
4300 };
4301
4302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4304 if (SWIG_arg_fail(1)) SWIG_fail;
4305 {
4306 arg2 = (int)(SWIG_As_int(obj1));
4307 if (SWIG_arg_fail(2)) SWIG_fail;
4308 }
4309 if (arg1) (arg1)->x = arg2;
4310
4311 Py_INCREF(Py_None); resultobj = Py_None;
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxPoint *arg1 = (wxPoint *) 0 ;
4321 int result;
4322 PyObject * obj0 = 0 ;
4323 char *kwnames[] = {
4324 (char *) "self", NULL
4325 };
4326
4327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4329 if (SWIG_arg_fail(1)) SWIG_fail;
4330 result = (int) ((arg1)->x);
4331
4332 {
4333 resultobj = SWIG_From_int((int)(result));
4334 }
4335 return resultobj;
4336 fail:
4337 return NULL;
4338 }
4339
4340
4341 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4342 PyObject *resultobj;
4343 wxPoint *arg1 = (wxPoint *) 0 ;
4344 int arg2 ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 char *kwnames[] = {
4348 (char *) "self",(char *) "y", NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4353 if (SWIG_arg_fail(1)) SWIG_fail;
4354 {
4355 arg2 = (int)(SWIG_As_int(obj1));
4356 if (SWIG_arg_fail(2)) SWIG_fail;
4357 }
4358 if (arg1) (arg1)->y = arg2;
4359
4360 Py_INCREF(Py_None); resultobj = Py_None;
4361 return resultobj;
4362 fail:
4363 return NULL;
4364 }
4365
4366
4367 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4368 PyObject *resultobj;
4369 wxPoint *arg1 = (wxPoint *) 0 ;
4370 int result;
4371 PyObject * obj0 = 0 ;
4372 char *kwnames[] = {
4373 (char *) "self", NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4378 if (SWIG_arg_fail(1)) SWIG_fail;
4379 result = (int) ((arg1)->y);
4380
4381 {
4382 resultobj = SWIG_From_int((int)(result));
4383 }
4384 return resultobj;
4385 fail:
4386 return NULL;
4387 }
4388
4389
4390 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj;
4392 int arg1 = (int) 0 ;
4393 int arg2 = (int) 0 ;
4394 wxPoint *result;
4395 PyObject * obj0 = 0 ;
4396 PyObject * obj1 = 0 ;
4397 char *kwnames[] = {
4398 (char *) "x",(char *) "y", NULL
4399 };
4400
4401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4402 if (obj0) {
4403 {
4404 arg1 = (int)(SWIG_As_int(obj0));
4405 if (SWIG_arg_fail(1)) SWIG_fail;
4406 }
4407 }
4408 if (obj1) {
4409 {
4410 arg2 = (int)(SWIG_As_int(obj1));
4411 if (SWIG_arg_fail(2)) SWIG_fail;
4412 }
4413 }
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = (wxPoint *)new wxPoint(arg1,arg2);
4417
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj;
4430 wxPoint *arg1 = (wxPoint *) 0 ;
4431 PyObject * obj0 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "self", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4438 if (SWIG_arg_fail(1)) SWIG_fail;
4439 {
4440 PyThreadState* __tstate = wxPyBeginAllowThreads();
4441 delete arg1;
4442
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 Py_INCREF(Py_None); resultobj = Py_None;
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4454 PyObject *resultobj;
4455 wxPoint *arg1 = (wxPoint *) 0 ;
4456 wxPoint *arg2 = 0 ;
4457 bool result;
4458 wxPoint temp2 ;
4459 PyObject * obj0 = 0 ;
4460 PyObject * obj1 = 0 ;
4461 char *kwnames[] = {
4462 (char *) "self",(char *) "pt", NULL
4463 };
4464
4465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4467 if (SWIG_arg_fail(1)) SWIG_fail;
4468 {
4469 arg2 = &temp2;
4470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4475
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 {
4480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4481 }
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxPoint *arg1 = (wxPoint *) 0 ;
4491 wxPoint *arg2 = 0 ;
4492 bool result;
4493 wxPoint temp2 ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self",(char *) "pt", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4510
4511 wxPyEndAllowThreads(__tstate);
4512 if (PyErr_Occurred()) SWIG_fail;
4513 }
4514 {
4515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516 }
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxPoint *arg1 = (wxPoint *) 0 ;
4526 wxPoint *arg2 = 0 ;
4527 wxPoint result;
4528 wxPoint temp2 ;
4529 PyObject * obj0 = 0 ;
4530 PyObject * obj1 = 0 ;
4531 char *kwnames[] = {
4532 (char *) "self",(char *) "pt", NULL
4533 };
4534
4535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(1)) SWIG_fail;
4538 {
4539 arg2 = &temp2;
4540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4541 }
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (arg1)->operator +((wxPoint const &)*arg2);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 wxPoint * resultptr;
4551 resultptr = new wxPoint((wxPoint &)(result));
4552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4553 }
4554 return resultobj;
4555 fail:
4556 return NULL;
4557 }
4558
4559
4560 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4561 PyObject *resultobj;
4562 wxPoint *arg1 = (wxPoint *) 0 ;
4563 wxPoint *arg2 = 0 ;
4564 wxPoint result;
4565 wxPoint temp2 ;
4566 PyObject * obj0 = 0 ;
4567 PyObject * obj1 = 0 ;
4568 char *kwnames[] = {
4569 (char *) "self",(char *) "pt", NULL
4570 };
4571
4572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4574 if (SWIG_arg_fail(1)) SWIG_fail;
4575 {
4576 arg2 = &temp2;
4577 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4578 }
4579 {
4580 PyThreadState* __tstate = wxPyBeginAllowThreads();
4581 result = (arg1)->operator -((wxPoint const &)*arg2);
4582
4583 wxPyEndAllowThreads(__tstate);
4584 if (PyErr_Occurred()) SWIG_fail;
4585 }
4586 {
4587 wxPoint * resultptr;
4588 resultptr = new wxPoint((wxPoint &)(result));
4589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4590 }
4591 return resultobj;
4592 fail:
4593 return NULL;
4594 }
4595
4596
4597 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4598 PyObject *resultobj;
4599 wxPoint *arg1 = (wxPoint *) 0 ;
4600 wxPoint *arg2 = 0 ;
4601 wxPoint *result;
4602 wxPoint temp2 ;
4603 PyObject * obj0 = 0 ;
4604 PyObject * obj1 = 0 ;
4605 char *kwnames[] = {
4606 (char *) "self",(char *) "pt", NULL
4607 };
4608
4609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4611 if (SWIG_arg_fail(1)) SWIG_fail;
4612 {
4613 arg2 = &temp2;
4614 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 {
4619 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4620 result = (wxPoint *) &_result_ref;
4621 }
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4627 return resultobj;
4628 fail:
4629 return NULL;
4630 }
4631
4632
4633 static PyObject *_wrap_Point___isub__(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___isub__",kwnames,&obj0,&obj1)) goto fail;
4646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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 {
4655 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4656 result = (wxPoint *) &_result_ref;
4657 }
4658
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4663 return resultobj;
4664 fail:
4665 return NULL;
4666 }
4667
4668
4669 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4670 PyObject *resultobj;
4671 wxPoint *arg1 = (wxPoint *) 0 ;
4672 long arg2 ;
4673 long arg3 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 PyObject * obj2 = 0 ;
4677 char *kwnames[] = {
4678 (char *) "self",(char *) "x",(char *) "y", NULL
4679 };
4680
4681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4683 if (SWIG_arg_fail(1)) SWIG_fail;
4684 {
4685 arg2 = (long)(SWIG_As_long(obj1));
4686 if (SWIG_arg_fail(2)) SWIG_fail;
4687 }
4688 {
4689 arg3 = (long)(SWIG_As_long(obj2));
4690 if (SWIG_arg_fail(3)) SWIG_fail;
4691 }
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 wxPoint_Set(arg1,arg2,arg3);
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 Py_INCREF(Py_None); resultobj = Py_None;
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj;
4708 wxPoint *arg1 = (wxPoint *) 0 ;
4709 PyObject *result;
4710 PyObject * obj0 = 0 ;
4711 char *kwnames[] = {
4712 (char *) "self", NULL
4713 };
4714
4715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4717 if (SWIG_arg_fail(1)) SWIG_fail;
4718 {
4719 PyThreadState* __tstate = wxPyBeginAllowThreads();
4720 result = (PyObject *)wxPoint_Get(arg1);
4721
4722 wxPyEndAllowThreads(__tstate);
4723 if (PyErr_Occurred()) SWIG_fail;
4724 }
4725 resultobj = result;
4726 return resultobj;
4727 fail:
4728 return NULL;
4729 }
4730
4731
4732 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4733 PyObject *obj;
4734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4735 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4736 Py_INCREF(obj);
4737 return Py_BuildValue((char *)"");
4738 }
4739 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4740 PyObject *resultobj;
4741 int arg1 = (int) 0 ;
4742 int arg2 = (int) 0 ;
4743 int arg3 = (int) 0 ;
4744 int arg4 = (int) 0 ;
4745 wxRect *result;
4746 PyObject * obj0 = 0 ;
4747 PyObject * obj1 = 0 ;
4748 PyObject * obj2 = 0 ;
4749 PyObject * obj3 = 0 ;
4750 char *kwnames[] = {
4751 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4752 };
4753
4754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4755 if (obj0) {
4756 {
4757 arg1 = (int)(SWIG_As_int(obj0));
4758 if (SWIG_arg_fail(1)) SWIG_fail;
4759 }
4760 }
4761 if (obj1) {
4762 {
4763 arg2 = (int)(SWIG_As_int(obj1));
4764 if (SWIG_arg_fail(2)) SWIG_fail;
4765 }
4766 }
4767 if (obj2) {
4768 {
4769 arg3 = (int)(SWIG_As_int(obj2));
4770 if (SWIG_arg_fail(3)) SWIG_fail;
4771 }
4772 }
4773 if (obj3) {
4774 {
4775 arg4 = (int)(SWIG_As_int(obj3));
4776 if (SWIG_arg_fail(4)) SWIG_fail;
4777 }
4778 }
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4782
4783 wxPyEndAllowThreads(__tstate);
4784 if (PyErr_Occurred()) SWIG_fail;
4785 }
4786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4787 return resultobj;
4788 fail:
4789 return NULL;
4790 }
4791
4792
4793 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4794 PyObject *resultobj;
4795 wxPoint *arg1 = 0 ;
4796 wxPoint *arg2 = 0 ;
4797 wxRect *result;
4798 wxPoint temp1 ;
4799 wxPoint temp2 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char *kwnames[] = {
4803 (char *) "topLeft",(char *) "bottomRight", NULL
4804 };
4805
4806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4807 {
4808 arg1 = &temp1;
4809 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4810 }
4811 {
4812 arg2 = &temp2;
4813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4814 }
4815 {
4816 PyThreadState* __tstate = wxPyBeginAllowThreads();
4817 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4818
4819 wxPyEndAllowThreads(__tstate);
4820 if (PyErr_Occurred()) SWIG_fail;
4821 }
4822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4823 return resultobj;
4824 fail:
4825 return NULL;
4826 }
4827
4828
4829 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4830 PyObject *resultobj;
4831 wxPoint *arg1 = 0 ;
4832 wxSize *arg2 = 0 ;
4833 wxRect *result;
4834 wxPoint temp1 ;
4835 wxSize temp2 ;
4836 PyObject * obj0 = 0 ;
4837 PyObject * obj1 = 0 ;
4838 char *kwnames[] = {
4839 (char *) "pos",(char *) "size", NULL
4840 };
4841
4842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4843 {
4844 arg1 = &temp1;
4845 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4846 }
4847 {
4848 arg2 = &temp2;
4849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4850 }
4851 {
4852 PyThreadState* __tstate = wxPyBeginAllowThreads();
4853 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4854
4855 wxPyEndAllowThreads(__tstate);
4856 if (PyErr_Occurred()) SWIG_fail;
4857 }
4858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4859 return resultobj;
4860 fail:
4861 return NULL;
4862 }
4863
4864
4865 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4866 PyObject *resultobj;
4867 wxSize *arg1 = 0 ;
4868 wxRect *result;
4869 wxSize temp1 ;
4870 PyObject * obj0 = 0 ;
4871 char *kwnames[] = {
4872 (char *) "size", NULL
4873 };
4874
4875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4876 {
4877 arg1 = &temp1;
4878 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4879 }
4880 {
4881 PyThreadState* __tstate = wxPyBeginAllowThreads();
4882 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4883
4884 wxPyEndAllowThreads(__tstate);
4885 if (PyErr_Occurred()) SWIG_fail;
4886 }
4887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4888 return resultobj;
4889 fail:
4890 return NULL;
4891 }
4892
4893
4894 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4895 PyObject *resultobj;
4896 wxRect *arg1 = (wxRect *) 0 ;
4897 PyObject * obj0 = 0 ;
4898 char *kwnames[] = {
4899 (char *) "self", NULL
4900 };
4901
4902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4904 if (SWIG_arg_fail(1)) SWIG_fail;
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 delete arg1;
4908
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 Py_INCREF(Py_None); resultobj = Py_None;
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj;
4921 wxRect *arg1 = (wxRect *) 0 ;
4922 int result;
4923 PyObject * obj0 = 0 ;
4924 char *kwnames[] = {
4925 (char *) "self", NULL
4926 };
4927
4928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4930 if (SWIG_arg_fail(1)) SWIG_fail;
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 result = (int)((wxRect const *)arg1)->GetX();
4934
4935 wxPyEndAllowThreads(__tstate);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 {
4939 resultobj = SWIG_From_int((int)(result));
4940 }
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj;
4949 wxRect *arg1 = (wxRect *) 0 ;
4950 int arg2 ;
4951 PyObject * obj0 = 0 ;
4952 PyObject * obj1 = 0 ;
4953 char *kwnames[] = {
4954 (char *) "self",(char *) "x", NULL
4955 };
4956
4957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4959 if (SWIG_arg_fail(1)) SWIG_fail;
4960 {
4961 arg2 = (int)(SWIG_As_int(obj1));
4962 if (SWIG_arg_fail(2)) SWIG_fail;
4963 }
4964 {
4965 PyThreadState* __tstate = wxPyBeginAllowThreads();
4966 (arg1)->SetX(arg2);
4967
4968 wxPyEndAllowThreads(__tstate);
4969 if (PyErr_Occurred()) SWIG_fail;
4970 }
4971 Py_INCREF(Py_None); resultobj = Py_None;
4972 return resultobj;
4973 fail:
4974 return NULL;
4975 }
4976
4977
4978 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4979 PyObject *resultobj;
4980 wxRect *arg1 = (wxRect *) 0 ;
4981 int result;
4982 PyObject * obj0 = 0 ;
4983 char *kwnames[] = {
4984 (char *) "self", NULL
4985 };
4986
4987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(1)) SWIG_fail;
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 result = (int)(arg1)->GetY();
4993
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 {
4998 resultobj = SWIG_From_int((int)(result));
4999 }
5000 return resultobj;
5001 fail:
5002 return NULL;
5003 }
5004
5005
5006 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5007 PyObject *resultobj;
5008 wxRect *arg1 = (wxRect *) 0 ;
5009 int arg2 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char *kwnames[] = {
5013 (char *) "self",(char *) "y", NULL
5014 };
5015
5016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5018 if (SWIG_arg_fail(1)) SWIG_fail;
5019 {
5020 arg2 = (int)(SWIG_As_int(obj1));
5021 if (SWIG_arg_fail(2)) SWIG_fail;
5022 }
5023 {
5024 PyThreadState* __tstate = wxPyBeginAllowThreads();
5025 (arg1)->SetY(arg2);
5026
5027 wxPyEndAllowThreads(__tstate);
5028 if (PyErr_Occurred()) SWIG_fail;
5029 }
5030 Py_INCREF(Py_None); resultobj = Py_None;
5031 return resultobj;
5032 fail:
5033 return NULL;
5034 }
5035
5036
5037 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5038 PyObject *resultobj;
5039 wxRect *arg1 = (wxRect *) 0 ;
5040 int result;
5041 PyObject * obj0 = 0 ;
5042 char *kwnames[] = {
5043 (char *) "self", NULL
5044 };
5045
5046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5048 if (SWIG_arg_fail(1)) SWIG_fail;
5049 {
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 result = (int)((wxRect const *)arg1)->GetWidth();
5052
5053 wxPyEndAllowThreads(__tstate);
5054 if (PyErr_Occurred()) SWIG_fail;
5055 }
5056 {
5057 resultobj = SWIG_From_int((int)(result));
5058 }
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj;
5067 wxRect *arg1 = (wxRect *) 0 ;
5068 int arg2 ;
5069 PyObject * obj0 = 0 ;
5070 PyObject * obj1 = 0 ;
5071 char *kwnames[] = {
5072 (char *) "self",(char *) "w", NULL
5073 };
5074
5075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5077 if (SWIG_arg_fail(1)) SWIG_fail;
5078 {
5079 arg2 = (int)(SWIG_As_int(obj1));
5080 if (SWIG_arg_fail(2)) SWIG_fail;
5081 }
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 (arg1)->SetWidth(arg2);
5085
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 Py_INCREF(Py_None); resultobj = Py_None;
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj;
5098 wxRect *arg1 = (wxRect *) 0 ;
5099 int result;
5100 PyObject * obj0 = 0 ;
5101 char *kwnames[] = {
5102 (char *) "self", NULL
5103 };
5104
5105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5107 if (SWIG_arg_fail(1)) SWIG_fail;
5108 {
5109 PyThreadState* __tstate = wxPyBeginAllowThreads();
5110 result = (int)((wxRect const *)arg1)->GetHeight();
5111
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 resultobj = SWIG_From_int((int)(result));
5117 }
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxRect *arg1 = (wxRect *) 0 ;
5127 int arg2 ;
5128 PyObject * obj0 = 0 ;
5129 PyObject * obj1 = 0 ;
5130 char *kwnames[] = {
5131 (char *) "self",(char *) "h", NULL
5132 };
5133
5134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5136 if (SWIG_arg_fail(1)) SWIG_fail;
5137 {
5138 arg2 = (int)(SWIG_As_int(obj1));
5139 if (SWIG_arg_fail(2)) SWIG_fail;
5140 }
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 (arg1)->SetHeight(arg2);
5144
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 Py_INCREF(Py_None); resultobj = Py_None;
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5156 PyObject *resultobj;
5157 wxRect *arg1 = (wxRect *) 0 ;
5158 wxPoint result;
5159 PyObject * obj0 = 0 ;
5160 char *kwnames[] = {
5161 (char *) "self", NULL
5162 };
5163
5164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5166 if (SWIG_arg_fail(1)) SWIG_fail;
5167 {
5168 PyThreadState* __tstate = wxPyBeginAllowThreads();
5169 result = ((wxRect const *)arg1)->GetPosition();
5170
5171 wxPyEndAllowThreads(__tstate);
5172 if (PyErr_Occurred()) SWIG_fail;
5173 }
5174 {
5175 wxPoint * resultptr;
5176 resultptr = new wxPoint((wxPoint &)(result));
5177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5178 }
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj;
5187 wxRect *arg1 = (wxRect *) 0 ;
5188 wxPoint *arg2 = 0 ;
5189 wxPoint temp2 ;
5190 PyObject * obj0 = 0 ;
5191 PyObject * obj1 = 0 ;
5192 char *kwnames[] = {
5193 (char *) "self",(char *) "p", NULL
5194 };
5195
5196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5198 if (SWIG_arg_fail(1)) SWIG_fail;
5199 {
5200 arg2 = &temp2;
5201 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5202 }
5203 {
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 (arg1)->SetPosition((wxPoint const &)*arg2);
5206
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 Py_INCREF(Py_None); resultobj = Py_None;
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5218 PyObject *resultobj;
5219 wxRect *arg1 = (wxRect *) 0 ;
5220 wxSize result;
5221 PyObject * obj0 = 0 ;
5222 char *kwnames[] = {
5223 (char *) "self", NULL
5224 };
5225
5226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5228 if (SWIG_arg_fail(1)) SWIG_fail;
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 result = ((wxRect const *)arg1)->GetSize();
5232
5233 wxPyEndAllowThreads(__tstate);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 {
5237 wxSize * resultptr;
5238 resultptr = new wxSize((wxSize &)(result));
5239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5240 }
5241 return resultobj;
5242 fail:
5243 return NULL;
5244 }
5245
5246
5247 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5248 PyObject *resultobj;
5249 wxRect *arg1 = (wxRect *) 0 ;
5250 wxSize *arg2 = 0 ;
5251 wxSize temp2 ;
5252 PyObject * obj0 = 0 ;
5253 PyObject * obj1 = 0 ;
5254 char *kwnames[] = {
5255 (char *) "self",(char *) "s", NULL
5256 };
5257
5258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5260 if (SWIG_arg_fail(1)) SWIG_fail;
5261 {
5262 arg2 = &temp2;
5263 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5264 }
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 (arg1)->SetSize((wxSize const &)*arg2);
5268
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 Py_INCREF(Py_None); resultobj = Py_None;
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj;
5281 wxRect *arg1 = (wxRect *) 0 ;
5282 wxPoint result;
5283 PyObject * obj0 = 0 ;
5284 char *kwnames[] = {
5285 (char *) "self", NULL
5286 };
5287
5288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5290 if (SWIG_arg_fail(1)) SWIG_fail;
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 result = ((wxRect const *)arg1)->GetTopLeft();
5294
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 {
5299 wxPoint * resultptr;
5300 resultptr = new wxPoint((wxPoint &)(result));
5301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5302 }
5303 return resultobj;
5304 fail:
5305 return NULL;
5306 }
5307
5308
5309 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5310 PyObject *resultobj;
5311 wxRect *arg1 = (wxRect *) 0 ;
5312 wxPoint *arg2 = 0 ;
5313 wxPoint temp2 ;
5314 PyObject * obj0 = 0 ;
5315 PyObject * obj1 = 0 ;
5316 char *kwnames[] = {
5317 (char *) "self",(char *) "p", NULL
5318 };
5319
5320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5322 if (SWIG_arg_fail(1)) SWIG_fail;
5323 {
5324 arg2 = &temp2;
5325 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5326 }
5327 {
5328 PyThreadState* __tstate = wxPyBeginAllowThreads();
5329 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5330
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 Py_INCREF(Py_None); resultobj = Py_None;
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj;
5343 wxRect *arg1 = (wxRect *) 0 ;
5344 wxPoint result;
5345 PyObject * obj0 = 0 ;
5346 char *kwnames[] = {
5347 (char *) "self", NULL
5348 };
5349
5350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5352 if (SWIG_arg_fail(1)) SWIG_fail;
5353 {
5354 PyThreadState* __tstate = wxPyBeginAllowThreads();
5355 result = ((wxRect const *)arg1)->GetBottomRight();
5356
5357 wxPyEndAllowThreads(__tstate);
5358 if (PyErr_Occurred()) SWIG_fail;
5359 }
5360 {
5361 wxPoint * resultptr;
5362 resultptr = new wxPoint((wxPoint &)(result));
5363 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5364 }
5365 return resultobj;
5366 fail:
5367 return NULL;
5368 }
5369
5370
5371 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5372 PyObject *resultobj;
5373 wxRect *arg1 = (wxRect *) 0 ;
5374 wxPoint *arg2 = 0 ;
5375 wxPoint temp2 ;
5376 PyObject * obj0 = 0 ;
5377 PyObject * obj1 = 0 ;
5378 char *kwnames[] = {
5379 (char *) "self",(char *) "p", NULL
5380 };
5381
5382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5384 if (SWIG_arg_fail(1)) SWIG_fail;
5385 {
5386 arg2 = &temp2;
5387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5388 }
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5392
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 Py_INCREF(Py_None); resultobj = Py_None;
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj;
5405 wxRect *arg1 = (wxRect *) 0 ;
5406 int result;
5407 PyObject * obj0 = 0 ;
5408 char *kwnames[] = {
5409 (char *) "self", NULL
5410 };
5411
5412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5414 if (SWIG_arg_fail(1)) SWIG_fail;
5415 {
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 result = (int)((wxRect const *)arg1)->GetLeft();
5418
5419 wxPyEndAllowThreads(__tstate);
5420 if (PyErr_Occurred()) SWIG_fail;
5421 }
5422 {
5423 resultobj = SWIG_From_int((int)(result));
5424 }
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5432 PyObject *resultobj;
5433 wxRect *arg1 = (wxRect *) 0 ;
5434 int result;
5435 PyObject * obj0 = 0 ;
5436 char *kwnames[] = {
5437 (char *) "self", NULL
5438 };
5439
5440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5442 if (SWIG_arg_fail(1)) SWIG_fail;
5443 {
5444 PyThreadState* __tstate = wxPyBeginAllowThreads();
5445 result = (int)((wxRect const *)arg1)->GetTop();
5446
5447 wxPyEndAllowThreads(__tstate);
5448 if (PyErr_Occurred()) SWIG_fail;
5449 }
5450 {
5451 resultobj = SWIG_From_int((int)(result));
5452 }
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxRect *arg1 = (wxRect *) 0 ;
5462 int result;
5463 PyObject * obj0 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 result = (int)((wxRect const *)arg1)->GetBottom();
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 {
5479 resultobj = SWIG_From_int((int)(result));
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 wxRect *arg1 = (wxRect *) 0 ;
5490 int result;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (int)((wxRect const *)arg1)->GetRight();
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 {
5507 resultobj = SWIG_From_int((int)(result));
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxRect *arg1 = (wxRect *) 0 ;
5518 int arg2 ;
5519 PyObject * obj0 = 0 ;
5520 PyObject * obj1 = 0 ;
5521 char *kwnames[] = {
5522 (char *) "self",(char *) "left", NULL
5523 };
5524
5525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5527 if (SWIG_arg_fail(1)) SWIG_fail;
5528 {
5529 arg2 = (int)(SWIG_As_int(obj1));
5530 if (SWIG_arg_fail(2)) SWIG_fail;
5531 }
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 (arg1)->SetLeft(arg2);
5535
5536 wxPyEndAllowThreads(__tstate);
5537 if (PyErr_Occurred()) SWIG_fail;
5538 }
5539 Py_INCREF(Py_None); resultobj = Py_None;
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5547 PyObject *resultobj;
5548 wxRect *arg1 = (wxRect *) 0 ;
5549 int arg2 ;
5550 PyObject * obj0 = 0 ;
5551 PyObject * obj1 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self",(char *) "right", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 arg2 = (int)(SWIG_As_int(obj1));
5561 if (SWIG_arg_fail(2)) SWIG_fail;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 (arg1)->SetRight(arg2);
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 Py_INCREF(Py_None); resultobj = Py_None;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj;
5579 wxRect *arg1 = (wxRect *) 0 ;
5580 int arg2 ;
5581 PyObject * obj0 = 0 ;
5582 PyObject * obj1 = 0 ;
5583 char *kwnames[] = {
5584 (char *) "self",(char *) "top", NULL
5585 };
5586
5587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5589 if (SWIG_arg_fail(1)) SWIG_fail;
5590 {
5591 arg2 = (int)(SWIG_As_int(obj1));
5592 if (SWIG_arg_fail(2)) SWIG_fail;
5593 }
5594 {
5595 PyThreadState* __tstate = wxPyBeginAllowThreads();
5596 (arg1)->SetTop(arg2);
5597
5598 wxPyEndAllowThreads(__tstate);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 Py_INCREF(Py_None); resultobj = Py_None;
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5609 PyObject *resultobj;
5610 wxRect *arg1 = (wxRect *) 0 ;
5611 int arg2 ;
5612 PyObject * obj0 = 0 ;
5613 PyObject * obj1 = 0 ;
5614 char *kwnames[] = {
5615 (char *) "self",(char *) "bottom", NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5620 if (SWIG_arg_fail(1)) SWIG_fail;
5621 {
5622 arg2 = (int)(SWIG_As_int(obj1));
5623 if (SWIG_arg_fail(2)) SWIG_fail;
5624 }
5625 {
5626 PyThreadState* __tstate = wxPyBeginAllowThreads();
5627 (arg1)->SetBottom(arg2);
5628
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 Py_INCREF(Py_None); resultobj = Py_None;
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj;
5641 wxRect *arg1 = (wxRect *) 0 ;
5642 int arg2 ;
5643 int arg3 ;
5644 wxRect *result;
5645 PyObject * obj0 = 0 ;
5646 PyObject * obj1 = 0 ;
5647 PyObject * obj2 = 0 ;
5648 char *kwnames[] = {
5649 (char *) "self",(char *) "dx",(char *) "dy", NULL
5650 };
5651
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5654 if (SWIG_arg_fail(1)) SWIG_fail;
5655 {
5656 arg2 = (int)(SWIG_As_int(obj1));
5657 if (SWIG_arg_fail(2)) SWIG_fail;
5658 }
5659 {
5660 arg3 = (int)(SWIG_As_int(obj2));
5661 if (SWIG_arg_fail(3)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 {
5666 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5667 result = (wxRect *) &_result_ref;
5668 }
5669
5670 wxPyEndAllowThreads(__tstate);
5671 if (PyErr_Occurred()) SWIG_fail;
5672 }
5673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5674 return resultobj;
5675 fail:
5676 return NULL;
5677 }
5678
5679
5680 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5681 PyObject *resultobj;
5682 wxRect *arg1 = (wxRect *) 0 ;
5683 int arg2 ;
5684 int arg3 ;
5685 wxRect *result;
5686 PyObject * obj0 = 0 ;
5687 PyObject * obj1 = 0 ;
5688 PyObject * obj2 = 0 ;
5689 char *kwnames[] = {
5690 (char *) "self",(char *) "dx",(char *) "dy", NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5695 if (SWIG_arg_fail(1)) SWIG_fail;
5696 {
5697 arg2 = (int)(SWIG_As_int(obj1));
5698 if (SWIG_arg_fail(2)) SWIG_fail;
5699 }
5700 {
5701 arg3 = (int)(SWIG_As_int(obj2));
5702 if (SWIG_arg_fail(3)) SWIG_fail;
5703 }
5704 {
5705 PyThreadState* __tstate = wxPyBeginAllowThreads();
5706 {
5707 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5708 result = (wxRect *) &_result_ref;
5709 }
5710
5711 wxPyEndAllowThreads(__tstate);
5712 if (PyErr_Occurred()) SWIG_fail;
5713 }
5714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj;
5723 wxRect *arg1 = (wxRect *) 0 ;
5724 int arg2 ;
5725 int arg3 ;
5726 PyObject * obj0 = 0 ;
5727 PyObject * obj1 = 0 ;
5728 PyObject * obj2 = 0 ;
5729 char *kwnames[] = {
5730 (char *) "self",(char *) "dx",(char *) "dy", NULL
5731 };
5732
5733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5735 if (SWIG_arg_fail(1)) SWIG_fail;
5736 {
5737 arg2 = (int)(SWIG_As_int(obj1));
5738 if (SWIG_arg_fail(2)) SWIG_fail;
5739 }
5740 {
5741 arg3 = (int)(SWIG_As_int(obj2));
5742 if (SWIG_arg_fail(3)) SWIG_fail;
5743 }
5744 {
5745 PyThreadState* __tstate = wxPyBeginAllowThreads();
5746 (arg1)->Offset(arg2,arg3);
5747
5748 wxPyEndAllowThreads(__tstate);
5749 if (PyErr_Occurred()) SWIG_fail;
5750 }
5751 Py_INCREF(Py_None); resultobj = Py_None;
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 wxRect *arg1 = (wxRect *) 0 ;
5761 wxPoint *arg2 = 0 ;
5762 wxPoint temp2 ;
5763 PyObject * obj0 = 0 ;
5764 PyObject * obj1 = 0 ;
5765 char *kwnames[] = {
5766 (char *) "self",(char *) "pt", NULL
5767 };
5768
5769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5771 if (SWIG_arg_fail(1)) SWIG_fail;
5772 {
5773 arg2 = &temp2;
5774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 (arg1)->Offset((wxPoint const &)*arg2);
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 Py_INCREF(Py_None); resultobj = Py_None;
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj;
5792 wxRect *arg1 = (wxRect *) 0 ;
5793 wxRect *arg2 = 0 ;
5794 wxRect result;
5795 wxRect temp2 ;
5796 PyObject * obj0 = 0 ;
5797 PyObject * obj1 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "self",(char *) "rect", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5804 if (SWIG_arg_fail(1)) SWIG_fail;
5805 {
5806 arg2 = &temp2;
5807 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5808 }
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 result = (arg1)->Intersect((wxRect const &)*arg2);
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 {
5817 wxRect * resultptr;
5818 resultptr = new wxRect((wxRect &)(result));
5819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5820 }
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj;
5829 wxRect *arg1 = (wxRect *) 0 ;
5830 wxRect *arg2 = 0 ;
5831 wxRect result;
5832 wxRect temp2 ;
5833 PyObject * obj0 = 0 ;
5834 PyObject * obj1 = 0 ;
5835 char *kwnames[] = {
5836 (char *) "self",(char *) "rect", NULL
5837 };
5838
5839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5841 if (SWIG_arg_fail(1)) SWIG_fail;
5842 {
5843 arg2 = &temp2;
5844 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5845 }
5846 {
5847 PyThreadState* __tstate = wxPyBeginAllowThreads();
5848 result = (arg1)->Union((wxRect const &)*arg2);
5849
5850 wxPyEndAllowThreads(__tstate);
5851 if (PyErr_Occurred()) SWIG_fail;
5852 }
5853 {
5854 wxRect * resultptr;
5855 resultptr = new wxRect((wxRect &)(result));
5856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5857 }
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj;
5866 wxRect *arg1 = (wxRect *) 0 ;
5867 wxRect *arg2 = 0 ;
5868 wxRect result;
5869 wxRect temp2 ;
5870 PyObject * obj0 = 0 ;
5871 PyObject * obj1 = 0 ;
5872 char *kwnames[] = {
5873 (char *) "self",(char *) "rect", NULL
5874 };
5875
5876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5878 if (SWIG_arg_fail(1)) SWIG_fail;
5879 {
5880 arg2 = &temp2;
5881 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5882 }
5883 {
5884 PyThreadState* __tstate = wxPyBeginAllowThreads();
5885 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5886
5887 wxPyEndAllowThreads(__tstate);
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 {
5891 wxRect * resultptr;
5892 resultptr = new wxRect((wxRect &)(result));
5893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5894 }
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxRect *arg1 = (wxRect *) 0 ;
5904 wxRect *arg2 = 0 ;
5905 wxRect *result;
5906 wxRect temp2 ;
5907 PyObject * obj0 = 0 ;
5908 PyObject * obj1 = 0 ;
5909 char *kwnames[] = {
5910 (char *) "self",(char *) "rect", NULL
5911 };
5912
5913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5915 if (SWIG_arg_fail(1)) SWIG_fail;
5916 {
5917 arg2 = &temp2;
5918 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5919 }
5920 {
5921 PyThreadState* __tstate = wxPyBeginAllowThreads();
5922 {
5923 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5924 result = (wxRect *) &_result_ref;
5925 }
5926
5927 wxPyEndAllowThreads(__tstate);
5928 if (PyErr_Occurred()) SWIG_fail;
5929 }
5930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxRect *arg1 = (wxRect *) 0 ;
5940 wxRect *arg2 = 0 ;
5941 bool result;
5942 wxRect temp2 ;
5943 PyObject * obj0 = 0 ;
5944 PyObject * obj1 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self",(char *) "rect", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 {
5953 arg2 = &temp2;
5954 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5955 }
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5965 }
5966 return resultobj;
5967 fail:
5968 return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxRect *arg1 = (wxRect *) 0 ;
5975 wxRect *arg2 = 0 ;
5976 bool result;
5977 wxRect temp2 ;
5978 PyObject * obj0 = 0 ;
5979 PyObject * obj1 = 0 ;
5980 char *kwnames[] = {
5981 (char *) "self",(char *) "rect", NULL
5982 };
5983
5984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5986 if (SWIG_arg_fail(1)) SWIG_fail;
5987 {
5988 arg2 = &temp2;
5989 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5990 }
5991 {
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 {
5999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6000 }
6001 return resultobj;
6002 fail:
6003 return NULL;
6004 }
6005
6006
6007 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6008 PyObject *resultobj;
6009 wxRect *arg1 = (wxRect *) 0 ;
6010 int arg2 ;
6011 int arg3 ;
6012 bool result;
6013 PyObject * obj0 = 0 ;
6014 PyObject * obj1 = 0 ;
6015 PyObject * obj2 = 0 ;
6016 char *kwnames[] = {
6017 (char *) "self",(char *) "x",(char *) "y", NULL
6018 };
6019
6020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6022 if (SWIG_arg_fail(1)) SWIG_fail;
6023 {
6024 arg2 = (int)(SWIG_As_int(obj1));
6025 if (SWIG_arg_fail(2)) SWIG_fail;
6026 }
6027 {
6028 arg3 = (int)(SWIG_As_int(obj2));
6029 if (SWIG_arg_fail(3)) SWIG_fail;
6030 }
6031 {
6032 PyThreadState* __tstate = wxPyBeginAllowThreads();
6033 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6034
6035 wxPyEndAllowThreads(__tstate);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 {
6039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6040 }
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 wxRect *arg1 = (wxRect *) 0 ;
6050 wxPoint *arg2 = 0 ;
6051 bool result;
6052 wxPoint temp2 ;
6053 PyObject * obj0 = 0 ;
6054 PyObject * obj1 = 0 ;
6055 char *kwnames[] = {
6056 (char *) "self",(char *) "pt", NULL
6057 };
6058
6059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6061 if (SWIG_arg_fail(1)) SWIG_fail;
6062 {
6063 arg2 = &temp2;
6064 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6065 }
6066 {
6067 PyThreadState* __tstate = wxPyBeginAllowThreads();
6068 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6069
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 {
6074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6075 }
6076 return resultobj;
6077 fail:
6078 return NULL;
6079 }
6080
6081
6082 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6083 PyObject *resultobj;
6084 wxRect *arg1 = (wxRect *) 0 ;
6085 wxRect *arg2 = 0 ;
6086 bool result;
6087 wxRect temp2 ;
6088 PyObject * obj0 = 0 ;
6089 PyObject * obj1 = 0 ;
6090 char *kwnames[] = {
6091 (char *) "self",(char *) "rect", NULL
6092 };
6093
6094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6096 if (SWIG_arg_fail(1)) SWIG_fail;
6097 {
6098 arg2 = &temp2;
6099 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6100 }
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6110 }
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj;
6119 wxRect *arg1 = (wxRect *) 0 ;
6120 int arg2 ;
6121 PyObject * obj0 = 0 ;
6122 PyObject * obj1 = 0 ;
6123 char *kwnames[] = {
6124 (char *) "self",(char *) "x", NULL
6125 };
6126
6127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6129 if (SWIG_arg_fail(1)) SWIG_fail;
6130 {
6131 arg2 = (int)(SWIG_As_int(obj1));
6132 if (SWIG_arg_fail(2)) SWIG_fail;
6133 }
6134 if (arg1) (arg1)->x = arg2;
6135
6136 Py_INCREF(Py_None); resultobj = Py_None;
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6144 PyObject *resultobj;
6145 wxRect *arg1 = (wxRect *) 0 ;
6146 int result;
6147 PyObject * obj0 = 0 ;
6148 char *kwnames[] = {
6149 (char *) "self", NULL
6150 };
6151
6152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6154 if (SWIG_arg_fail(1)) SWIG_fail;
6155 result = (int) ((arg1)->x);
6156
6157 {
6158 resultobj = SWIG_From_int((int)(result));
6159 }
6160 return resultobj;
6161 fail:
6162 return NULL;
6163 }
6164
6165
6166 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6167 PyObject *resultobj;
6168 wxRect *arg1 = (wxRect *) 0 ;
6169 int arg2 ;
6170 PyObject * obj0 = 0 ;
6171 PyObject * obj1 = 0 ;
6172 char *kwnames[] = {
6173 (char *) "self",(char *) "y", NULL
6174 };
6175
6176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6178 if (SWIG_arg_fail(1)) SWIG_fail;
6179 {
6180 arg2 = (int)(SWIG_As_int(obj1));
6181 if (SWIG_arg_fail(2)) SWIG_fail;
6182 }
6183 if (arg1) (arg1)->y = arg2;
6184
6185 Py_INCREF(Py_None); resultobj = Py_None;
6186 return resultobj;
6187 fail:
6188 return NULL;
6189 }
6190
6191
6192 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6193 PyObject *resultobj;
6194 wxRect *arg1 = (wxRect *) 0 ;
6195 int result;
6196 PyObject * obj0 = 0 ;
6197 char *kwnames[] = {
6198 (char *) "self", NULL
6199 };
6200
6201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6203 if (SWIG_arg_fail(1)) SWIG_fail;
6204 result = (int) ((arg1)->y);
6205
6206 {
6207 resultobj = SWIG_From_int((int)(result));
6208 }
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6216 PyObject *resultobj;
6217 wxRect *arg1 = (wxRect *) 0 ;
6218 int arg2 ;
6219 PyObject * obj0 = 0 ;
6220 PyObject * obj1 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self",(char *) "width", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 {
6229 arg2 = (int)(SWIG_As_int(obj1));
6230 if (SWIG_arg_fail(2)) SWIG_fail;
6231 }
6232 if (arg1) (arg1)->width = arg2;
6233
6234 Py_INCREF(Py_None); resultobj = Py_None;
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6242 PyObject *resultobj;
6243 wxRect *arg1 = (wxRect *) 0 ;
6244 int result;
6245 PyObject * obj0 = 0 ;
6246 char *kwnames[] = {
6247 (char *) "self", NULL
6248 };
6249
6250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6252 if (SWIG_arg_fail(1)) SWIG_fail;
6253 result = (int) ((arg1)->width);
6254
6255 {
6256 resultobj = SWIG_From_int((int)(result));
6257 }
6258 return resultobj;
6259 fail:
6260 return NULL;
6261 }
6262
6263
6264 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6265 PyObject *resultobj;
6266 wxRect *arg1 = (wxRect *) 0 ;
6267 int arg2 ;
6268 PyObject * obj0 = 0 ;
6269 PyObject * obj1 = 0 ;
6270 char *kwnames[] = {
6271 (char *) "self",(char *) "height", NULL
6272 };
6273
6274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6276 if (SWIG_arg_fail(1)) SWIG_fail;
6277 {
6278 arg2 = (int)(SWIG_As_int(obj1));
6279 if (SWIG_arg_fail(2)) SWIG_fail;
6280 }
6281 if (arg1) (arg1)->height = arg2;
6282
6283 Py_INCREF(Py_None); resultobj = Py_None;
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int result;
6294 PyObject * obj0 = 0 ;
6295 char *kwnames[] = {
6296 (char *) "self", NULL
6297 };
6298
6299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 result = (int) ((arg1)->height);
6303
6304 {
6305 resultobj = SWIG_From_int((int)(result));
6306 }
6307 return resultobj;
6308 fail:
6309 return NULL;
6310 }
6311
6312
6313 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6314 PyObject *resultobj;
6315 wxRect *arg1 = (wxRect *) 0 ;
6316 int arg2 = (int) 0 ;
6317 int arg3 = (int) 0 ;
6318 int arg4 = (int) 0 ;
6319 int arg5 = (int) 0 ;
6320 PyObject * obj0 = 0 ;
6321 PyObject * obj1 = 0 ;
6322 PyObject * obj2 = 0 ;
6323 PyObject * obj3 = 0 ;
6324 PyObject * obj4 = 0 ;
6325 char *kwnames[] = {
6326 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6327 };
6328
6329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6331 if (SWIG_arg_fail(1)) SWIG_fail;
6332 if (obj1) {
6333 {
6334 arg2 = (int)(SWIG_As_int(obj1));
6335 if (SWIG_arg_fail(2)) SWIG_fail;
6336 }
6337 }
6338 if (obj2) {
6339 {
6340 arg3 = (int)(SWIG_As_int(obj2));
6341 if (SWIG_arg_fail(3)) SWIG_fail;
6342 }
6343 }
6344 if (obj3) {
6345 {
6346 arg4 = (int)(SWIG_As_int(obj3));
6347 if (SWIG_arg_fail(4)) SWIG_fail;
6348 }
6349 }
6350 if (obj4) {
6351 {
6352 arg5 = (int)(SWIG_As_int(obj4));
6353 if (SWIG_arg_fail(5)) SWIG_fail;
6354 }
6355 }
6356 {
6357 PyThreadState* __tstate = wxPyBeginAllowThreads();
6358 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6359
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 Py_INCREF(Py_None); resultobj = Py_None;
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6371 PyObject *resultobj;
6372 wxRect *arg1 = (wxRect *) 0 ;
6373 PyObject *result;
6374 PyObject * obj0 = 0 ;
6375 char *kwnames[] = {
6376 (char *) "self", NULL
6377 };
6378
6379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6381 if (SWIG_arg_fail(1)) SWIG_fail;
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 result = (PyObject *)wxRect_Get(arg1);
6385
6386 wxPyEndAllowThreads(__tstate);
6387 if (PyErr_Occurred()) SWIG_fail;
6388 }
6389 resultobj = result;
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6397 PyObject *obj;
6398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6399 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6400 Py_INCREF(obj);
6401 return Py_BuildValue((char *)"");
6402 }
6403 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 wxRect *arg1 = (wxRect *) 0 ;
6406 wxRect *arg2 = (wxRect *) 0 ;
6407 PyObject *result;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char *kwnames[] = {
6411 (char *) "r1",(char *) "r2", NULL
6412 };
6413
6414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6416 if (SWIG_arg_fail(1)) SWIG_fail;
6417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6418 if (SWIG_arg_fail(2)) SWIG_fail;
6419 {
6420 if (!wxPyCheckForApp()) SWIG_fail;
6421 PyThreadState* __tstate = wxPyBeginAllowThreads();
6422 result = (PyObject *)wxIntersectRect(arg1,arg2);
6423
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = result;
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj;
6436 double arg1 = (double) 0.0 ;
6437 double arg2 = (double) 0.0 ;
6438 wxPoint2D *result;
6439 PyObject * obj0 = 0 ;
6440 PyObject * obj1 = 0 ;
6441 char *kwnames[] = {
6442 (char *) "x",(char *) "y", NULL
6443 };
6444
6445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6446 if (obj0) {
6447 {
6448 arg1 = (double)(SWIG_As_double(obj0));
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 }
6451 }
6452 if (obj1) {
6453 {
6454 arg2 = (double)(SWIG_As_double(obj1));
6455 if (SWIG_arg_fail(2)) SWIG_fail;
6456 }
6457 }
6458 {
6459 PyThreadState* __tstate = wxPyBeginAllowThreads();
6460 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6461
6462 wxPyEndAllowThreads(__tstate);
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj;
6474 wxPoint2D *arg1 = 0 ;
6475 wxPoint2D *result;
6476 wxPoint2D temp1 ;
6477 PyObject * obj0 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "pt", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6483 {
6484 arg1 = &temp1;
6485 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6486 }
6487 {
6488 PyThreadState* __tstate = wxPyBeginAllowThreads();
6489 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6490
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6502 PyObject *resultobj;
6503 wxPoint *arg1 = 0 ;
6504 wxPoint2D *result;
6505 wxPoint temp1 ;
6506 PyObject * obj0 = 0 ;
6507 char *kwnames[] = {
6508 (char *) "pt", NULL
6509 };
6510
6511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6512 {
6513 arg1 = &temp1;
6514 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6515 }
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6519
6520 wxPyEndAllowThreads(__tstate);
6521 if (PyErr_Occurred()) SWIG_fail;
6522 }
6523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6524 return resultobj;
6525 fail:
6526 return NULL;
6527 }
6528
6529
6530 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6531 PyObject *resultobj;
6532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6533 int *arg2 = (int *) 0 ;
6534 int *arg3 = (int *) 0 ;
6535 int temp2 ;
6536 int res2 = 0 ;
6537 int temp3 ;
6538 int res3 = 0 ;
6539 PyObject * obj0 = 0 ;
6540 char *kwnames[] = {
6541 (char *) "self", NULL
6542 };
6543
6544 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6545 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6548 if (SWIG_arg_fail(1)) SWIG_fail;
6549 {
6550 PyThreadState* __tstate = wxPyBeginAllowThreads();
6551 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6552
6553 wxPyEndAllowThreads(__tstate);
6554 if (PyErr_Occurred()) SWIG_fail;
6555 }
6556 Py_INCREF(Py_None); resultobj = Py_None;
6557 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6558 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6559 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6560 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6561 return resultobj;
6562 fail:
6563 return NULL;
6564 }
6565
6566
6567 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6568 PyObject *resultobj;
6569 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6570 int *arg2 = (int *) 0 ;
6571 int *arg3 = (int *) 0 ;
6572 int temp2 ;
6573 int res2 = 0 ;
6574 int temp3 ;
6575 int res3 = 0 ;
6576 PyObject * obj0 = 0 ;
6577 char *kwnames[] = {
6578 (char *) "self", NULL
6579 };
6580
6581 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6582 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6585 if (SWIG_arg_fail(1)) SWIG_fail;
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6589
6590 wxPyEndAllowThreads(__tstate);
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 Py_INCREF(Py_None); resultobj = Py_None;
6594 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6595 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6596 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6597 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6605 PyObject *resultobj;
6606 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6607 double result;
6608 PyObject * obj0 = 0 ;
6609 char *kwnames[] = {
6610 (char *) "self", NULL
6611 };
6612
6613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6615 if (SWIG_arg_fail(1)) SWIG_fail;
6616 {
6617 PyThreadState* __tstate = wxPyBeginAllowThreads();
6618 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6619
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 {
6624 resultobj = SWIG_From_double((double)(result));
6625 }
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6633 PyObject *resultobj;
6634 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6635 double result;
6636 PyObject * obj0 = 0 ;
6637 char *kwnames[] = {
6638 (char *) "self", NULL
6639 };
6640
6641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6643 if (SWIG_arg_fail(1)) SWIG_fail;
6644 {
6645 PyThreadState* __tstate = wxPyBeginAllowThreads();
6646 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6647
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 {
6652 resultobj = SWIG_From_double((double)(result));
6653 }
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj;
6662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6663 double arg2 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char *kwnames[] = {
6667 (char *) "self",(char *) "length", NULL
6668 };
6669
6670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6672 if (SWIG_arg_fail(1)) SWIG_fail;
6673 {
6674 arg2 = (double)(SWIG_As_double(obj1));
6675 if (SWIG_arg_fail(2)) SWIG_fail;
6676 }
6677 {
6678 PyThreadState* __tstate = wxPyBeginAllowThreads();
6679 (arg1)->SetVectorLength(arg2);
6680
6681 wxPyEndAllowThreads(__tstate);
6682 if (PyErr_Occurred()) SWIG_fail;
6683 }
6684 Py_INCREF(Py_None); resultobj = Py_None;
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj;
6693 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6694 double arg2 ;
6695 PyObject * obj0 = 0 ;
6696 PyObject * obj1 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "degrees", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = (double)(SWIG_As_double(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 (arg1)->SetVectorAngle(arg2);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 Py_INCREF(Py_None); resultobj = Py_None;
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj;
6724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6725 wxPoint2D *arg2 = 0 ;
6726 double result;
6727 wxPoint2D temp2 ;
6728 PyObject * obj0 = 0 ;
6729 PyObject * obj1 = 0 ;
6730 char *kwnames[] = {
6731 (char *) "self",(char *) "pt", NULL
6732 };
6733
6734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6736 if (SWIG_arg_fail(1)) SWIG_fail;
6737 {
6738 arg2 = &temp2;
6739 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6740 }
6741 {
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6744
6745 wxPyEndAllowThreads(__tstate);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 {
6749 resultobj = SWIG_From_double((double)(result));
6750 }
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj;
6759 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6760 wxPoint2D *arg2 = 0 ;
6761 double result;
6762 wxPoint2D temp2 ;
6763 PyObject * obj0 = 0 ;
6764 PyObject * obj1 = 0 ;
6765 char *kwnames[] = {
6766 (char *) "self",(char *) "pt", NULL
6767 };
6768
6769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6771 if (SWIG_arg_fail(1)) SWIG_fail;
6772 {
6773 arg2 = &temp2;
6774 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6775 }
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 {
6784 resultobj = SWIG_From_double((double)(result));
6785 }
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj;
6794 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6795 wxPoint2D *arg2 = 0 ;
6796 double result;
6797 wxPoint2D temp2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char *kwnames[] = {
6801 (char *) "self",(char *) "vec", NULL
6802 };
6803
6804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6806 if (SWIG_arg_fail(1)) SWIG_fail;
6807 {
6808 arg2 = &temp2;
6809 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6810 }
6811 {
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6814
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 {
6819 resultobj = SWIG_From_double((double)(result));
6820 }
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6828 PyObject *resultobj;
6829 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6830 wxPoint2D *arg2 = 0 ;
6831 double result;
6832 wxPoint2D temp2 ;
6833 PyObject * obj0 = 0 ;
6834 PyObject * obj1 = 0 ;
6835 char *kwnames[] = {
6836 (char *) "self",(char *) "vec", NULL
6837 };
6838
6839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6841 if (SWIG_arg_fail(1)) SWIG_fail;
6842 {
6843 arg2 = &temp2;
6844 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6845 }
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6849
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 {
6854 resultobj = SWIG_From_double((double)(result));
6855 }
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj;
6864 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6865 wxPoint2D result;
6866 PyObject * obj0 = 0 ;
6867 char *kwnames[] = {
6868 (char *) "self", NULL
6869 };
6870
6871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6873 if (SWIG_arg_fail(1)) SWIG_fail;
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (arg1)->operator -();
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 wxPoint2D * resultptr;
6883 resultptr = new wxPoint2D((wxPoint2D &)(result));
6884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6885 }
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj;
6894 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6895 wxPoint2D *arg2 = 0 ;
6896 wxPoint2D *result;
6897 wxPoint2D temp2 ;
6898 PyObject * obj0 = 0 ;
6899 PyObject * obj1 = 0 ;
6900 char *kwnames[] = {
6901 (char *) "self",(char *) "pt", NULL
6902 };
6903
6904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6906 if (SWIG_arg_fail(1)) SWIG_fail;
6907 {
6908 arg2 = &temp2;
6909 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6910 }
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 {
6914 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6915 result = (wxPoint2D *) &_result_ref;
6916 }
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj;
6930 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6931 wxPoint2D *arg2 = 0 ;
6932 wxPoint2D *result;
6933 wxPoint2D temp2 ;
6934 PyObject * obj0 = 0 ;
6935 PyObject * obj1 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self",(char *) "pt", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
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 {
6950 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6951 result = (wxPoint2D *) &_result_ref;
6952 }
6953
6954 wxPyEndAllowThreads(__tstate);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6965 PyObject *resultobj;
6966 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6967 wxPoint2D *arg2 = 0 ;
6968 wxPoint2D *result;
6969 wxPoint2D temp2 ;
6970 PyObject * obj0 = 0 ;
6971 PyObject * obj1 = 0 ;
6972 char *kwnames[] = {
6973 (char *) "self",(char *) "pt", NULL
6974 };
6975
6976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6978 if (SWIG_arg_fail(1)) SWIG_fail;
6979 {
6980 arg2 = &temp2;
6981 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6982 }
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 {
6986 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6987 result = (wxPoint2D *) &_result_ref;
6988 }
6989
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj;
7002 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7003 wxPoint2D *arg2 = 0 ;
7004 wxPoint2D *result;
7005 wxPoint2D temp2 ;
7006 PyObject * obj0 = 0 ;
7007 PyObject * obj1 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "self",(char *) "pt", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7014 if (SWIG_arg_fail(1)) SWIG_fail;
7015 {
7016 arg2 = &temp2;
7017 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7018 }
7019 {
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 {
7022 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7023 result = (wxPoint2D *) &_result_ref;
7024 }
7025
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7037 PyObject *resultobj;
7038 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7039 wxPoint2D *arg2 = 0 ;
7040 bool result;
7041 wxPoint2D temp2 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char *kwnames[] = {
7045 (char *) "self",(char *) "pt", NULL
7046 };
7047
7048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7050 if (SWIG_arg_fail(1)) SWIG_fail;
7051 {
7052 arg2 = &temp2;
7053 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7054 }
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7058
7059 wxPyEndAllowThreads(__tstate);
7060 if (PyErr_Occurred()) SWIG_fail;
7061 }
7062 {
7063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7064 }
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj;
7073 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7074 wxPoint2D *arg2 = 0 ;
7075 bool result;
7076 wxPoint2D temp2 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 char *kwnames[] = {
7080 (char *) "self",(char *) "pt", NULL
7081 };
7082
7083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7085 if (SWIG_arg_fail(1)) SWIG_fail;
7086 {
7087 arg2 = &temp2;
7088 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7089 }
7090 {
7091 PyThreadState* __tstate = wxPyBeginAllowThreads();
7092 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7093
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 {
7098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7099 }
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7107 PyObject *resultobj;
7108 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7109 double arg2 ;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 char *kwnames[] = {
7113 (char *) "self",(char *) "m_x", NULL
7114 };
7115
7116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7118 if (SWIG_arg_fail(1)) SWIG_fail;
7119 {
7120 arg2 = (double)(SWIG_As_double(obj1));
7121 if (SWIG_arg_fail(2)) SWIG_fail;
7122 }
7123 if (arg1) (arg1)->m_x = arg2;
7124
7125 Py_INCREF(Py_None); resultobj = Py_None;
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7133 PyObject *resultobj;
7134 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7135 double result;
7136 PyObject * obj0 = 0 ;
7137 char *kwnames[] = {
7138 (char *) "self", NULL
7139 };
7140
7141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7143 if (SWIG_arg_fail(1)) SWIG_fail;
7144 result = (double) ((arg1)->m_x);
7145
7146 {
7147 resultobj = SWIG_From_double((double)(result));
7148 }
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj;
7157 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7158 double arg2 ;
7159 PyObject * obj0 = 0 ;
7160 PyObject * obj1 = 0 ;
7161 char *kwnames[] = {
7162 (char *) "self",(char *) "m_y", NULL
7163 };
7164
7165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7167 if (SWIG_arg_fail(1)) SWIG_fail;
7168 {
7169 arg2 = (double)(SWIG_As_double(obj1));
7170 if (SWIG_arg_fail(2)) SWIG_fail;
7171 }
7172 if (arg1) (arg1)->m_y = arg2;
7173
7174 Py_INCREF(Py_None); resultobj = Py_None;
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj;
7183 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7184 double result;
7185 PyObject * obj0 = 0 ;
7186 char *kwnames[] = {
7187 (char *) "self", NULL
7188 };
7189
7190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7192 if (SWIG_arg_fail(1)) SWIG_fail;
7193 result = (double) ((arg1)->m_y);
7194
7195 {
7196 resultobj = SWIG_From_double((double)(result));
7197 }
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj;
7206 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7207 double arg2 = (double) 0 ;
7208 double arg3 = (double) 0 ;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 PyObject * obj2 = 0 ;
7212 char *kwnames[] = {
7213 (char *) "self",(char *) "x",(char *) "y", NULL
7214 };
7215
7216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7218 if (SWIG_arg_fail(1)) SWIG_fail;
7219 if (obj1) {
7220 {
7221 arg2 = (double)(SWIG_As_double(obj1));
7222 if (SWIG_arg_fail(2)) SWIG_fail;
7223 }
7224 }
7225 if (obj2) {
7226 {
7227 arg3 = (double)(SWIG_As_double(obj2));
7228 if (SWIG_arg_fail(3)) SWIG_fail;
7229 }
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 wxPoint2D_Set(arg1,arg2,arg3);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 Py_INCREF(Py_None); resultobj = Py_None;
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7248 PyObject *result;
7249 PyObject * obj0 = 0 ;
7250 char *kwnames[] = {
7251 (char *) "self", NULL
7252 };
7253
7254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7256 if (SWIG_arg_fail(1)) SWIG_fail;
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (PyObject *)wxPoint2D_Get(arg1);
7260
7261 wxPyEndAllowThreads(__tstate);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 resultobj = result;
7265 return resultobj;
7266 fail:
7267 return NULL;
7268 }
7269
7270
7271 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7272 PyObject *obj;
7273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7274 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7275 Py_INCREF(obj);
7276 return Py_BuildValue((char *)"");
7277 }
7278 static int _wrap_DefaultPosition_set(PyObject *) {
7279 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7280 return 1;
7281 }
7282
7283
7284 static PyObject *_wrap_DefaultPosition_get(void) {
7285 PyObject *pyobj;
7286
7287 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7288 return pyobj;
7289 }
7290
7291
7292 static int _wrap_DefaultSize_set(PyObject *) {
7293 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7294 return 1;
7295 }
7296
7297
7298 static PyObject *_wrap_DefaultSize_get(void) {
7299 PyObject *pyobj;
7300
7301 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7302 return pyobj;
7303 }
7304
7305
7306 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7307 PyObject *resultobj;
7308 PyObject *arg1 = (PyObject *) 0 ;
7309 wxPyInputStream *result;
7310 PyObject * obj0 = 0 ;
7311 char *kwnames[] = {
7312 (char *) "p", NULL
7313 };
7314
7315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7316 arg1 = obj0;
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj;
7333 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7334 PyObject * obj0 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 delete arg1;
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 Py_INCREF(Py_None); resultobj = Py_None;
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj;
7358 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7359 PyObject * obj0 = 0 ;
7360 char *kwnames[] = {
7361 (char *) "self", NULL
7362 };
7363
7364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7366 if (SWIG_arg_fail(1)) SWIG_fail;
7367 {
7368 PyThreadState* __tstate = wxPyBeginAllowThreads();
7369 (arg1)->close();
7370
7371 wxPyEndAllowThreads(__tstate);
7372 if (PyErr_Occurred()) SWIG_fail;
7373 }
7374 Py_INCREF(Py_None); resultobj = Py_None;
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7382 PyObject *resultobj;
7383 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7384 PyObject * obj0 = 0 ;
7385 char *kwnames[] = {
7386 (char *) "self", NULL
7387 };
7388
7389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7391 if (SWIG_arg_fail(1)) SWIG_fail;
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 (arg1)->flush();
7395
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 Py_INCREF(Py_None); resultobj = Py_None;
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7407 PyObject *resultobj;
7408 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7409 bool result;
7410 PyObject * obj0 = 0 ;
7411 char *kwnames[] = {
7412 (char *) "self", NULL
7413 };
7414
7415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7417 if (SWIG_arg_fail(1)) SWIG_fail;
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (bool)(arg1)->eof();
7421
7422 wxPyEndAllowThreads(__tstate);
7423 if (PyErr_Occurred()) SWIG_fail;
7424 }
7425 {
7426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7427 }
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7437 int arg2 = (int) -1 ;
7438 PyObject *result;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 char *kwnames[] = {
7442 (char *) "self",(char *) "size", NULL
7443 };
7444
7445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7447 if (SWIG_arg_fail(1)) SWIG_fail;
7448 if (obj1) {
7449 {
7450 arg2 = (int)(SWIG_As_int(obj1));
7451 if (SWIG_arg_fail(2)) SWIG_fail;
7452 }
7453 }
7454 {
7455 PyThreadState* __tstate = wxPyBeginAllowThreads();
7456 result = (PyObject *)(arg1)->read(arg2);
7457
7458 wxPyEndAllowThreads(__tstate);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 resultobj = result;
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj;
7470 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7471 int arg2 = (int) -1 ;
7472 PyObject *result;
7473 PyObject * obj0 = 0 ;
7474 PyObject * obj1 = 0 ;
7475 char *kwnames[] = {
7476 (char *) "self",(char *) "size", NULL
7477 };
7478
7479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7481 if (SWIG_arg_fail(1)) SWIG_fail;
7482 if (obj1) {
7483 {
7484 arg2 = (int)(SWIG_As_int(obj1));
7485 if (SWIG_arg_fail(2)) SWIG_fail;
7486 }
7487 }
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 result = (PyObject *)(arg1)->readline(arg2);
7491
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 resultobj = result;
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj;
7504 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7505 int arg2 = (int) -1 ;
7506 PyObject *result;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 char *kwnames[] = {
7510 (char *) "self",(char *) "sizehint", NULL
7511 };
7512
7513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7515 if (SWIG_arg_fail(1)) SWIG_fail;
7516 if (obj1) {
7517 {
7518 arg2 = (int)(SWIG_As_int(obj1));
7519 if (SWIG_arg_fail(2)) SWIG_fail;
7520 }
7521 }
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 result = (PyObject *)(arg1)->readlines(arg2);
7525
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 resultobj = result;
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj;
7538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7539 int arg2 ;
7540 int arg3 = (int) 0 ;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 PyObject * obj2 = 0 ;
7544 char *kwnames[] = {
7545 (char *) "self",(char *) "offset",(char *) "whence", NULL
7546 };
7547
7548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7550 if (SWIG_arg_fail(1)) SWIG_fail;
7551 {
7552 arg2 = (int)(SWIG_As_int(obj1));
7553 if (SWIG_arg_fail(2)) SWIG_fail;
7554 }
7555 if (obj2) {
7556 {
7557 arg3 = (int)(SWIG_As_int(obj2));
7558 if (SWIG_arg_fail(3)) SWIG_fail;
7559 }
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 (arg1)->seek(arg2,arg3);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 Py_INCREF(Py_None); resultobj = Py_None;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj;
7577 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7578 int result;
7579 PyObject * obj0 = 0 ;
7580 char *kwnames[] = {
7581 (char *) "self", NULL
7582 };
7583
7584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7586 if (SWIG_arg_fail(1)) SWIG_fail;
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (int)(arg1)->tell();
7590
7591 wxPyEndAllowThreads(__tstate);
7592 if (PyErr_Occurred()) SWIG_fail;
7593 }
7594 {
7595 resultobj = SWIG_From_int((int)(result));
7596 }
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7604 PyObject *resultobj;
7605 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7606 char result;
7607 PyObject * obj0 = 0 ;
7608 char *kwnames[] = {
7609 (char *) "self", NULL
7610 };
7611
7612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7614 if (SWIG_arg_fail(1)) SWIG_fail;
7615 {
7616 PyThreadState* __tstate = wxPyBeginAllowThreads();
7617 result = (char)(arg1)->Peek();
7618
7619 wxPyEndAllowThreads(__tstate);
7620 if (PyErr_Occurred()) SWIG_fail;
7621 }
7622 {
7623 resultobj = SWIG_From_char((char)(result));
7624 }
7625 return resultobj;
7626 fail:
7627 return NULL;
7628 }
7629
7630
7631 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj;
7633 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7634 char result;
7635 PyObject * obj0 = 0 ;
7636 char *kwnames[] = {
7637 (char *) "self", NULL
7638 };
7639
7640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7642 if (SWIG_arg_fail(1)) SWIG_fail;
7643 {
7644 PyThreadState* __tstate = wxPyBeginAllowThreads();
7645 result = (char)(arg1)->GetC();
7646
7647 wxPyEndAllowThreads(__tstate);
7648 if (PyErr_Occurred()) SWIG_fail;
7649 }
7650 {
7651 resultobj = SWIG_From_char((char)(result));
7652 }
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj;
7661 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7662 size_t result;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (size_t)(arg1)->LastRead();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj;
7689 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7690 bool result;
7691 PyObject * obj0 = 0 ;
7692 char *kwnames[] = {
7693 (char *) "self", NULL
7694 };
7695
7696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7698 if (SWIG_arg_fail(1)) SWIG_fail;
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = (bool)(arg1)->CanRead();
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 {
7707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7708 }
7709 return resultobj;
7710 fail:
7711 return NULL;
7712 }
7713
7714
7715 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7716 PyObject *resultobj;
7717 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7718 bool result;
7719 PyObject * obj0 = 0 ;
7720 char *kwnames[] = {
7721 (char *) "self", NULL
7722 };
7723
7724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7726 if (SWIG_arg_fail(1)) SWIG_fail;
7727 {
7728 PyThreadState* __tstate = wxPyBeginAllowThreads();
7729 result = (bool)(arg1)->Eof();
7730
7731 wxPyEndAllowThreads(__tstate);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj;
7745 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7746 char arg2 ;
7747 bool result;
7748 PyObject * obj0 = 0 ;
7749 PyObject * obj1 = 0 ;
7750 char *kwnames[] = {
7751 (char *) "self",(char *) "c", NULL
7752 };
7753
7754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7756 if (SWIG_arg_fail(1)) SWIG_fail;
7757 {
7758 arg2 = (char)(SWIG_As_char(obj1));
7759 if (SWIG_arg_fail(2)) SWIG_fail;
7760 }
7761 {
7762 PyThreadState* __tstate = wxPyBeginAllowThreads();
7763 result = (bool)(arg1)->Ungetch(arg2);
7764
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj;
7779 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7780 long arg2 ;
7781 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7782 long result;
7783 PyObject * obj0 = 0 ;
7784 PyObject * obj1 = 0 ;
7785 PyObject * obj2 = 0 ;
7786 char *kwnames[] = {
7787 (char *) "self",(char *) "pos",(char *) "mode", NULL
7788 };
7789
7790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7792 if (SWIG_arg_fail(1)) SWIG_fail;
7793 {
7794 arg2 = (long)(SWIG_As_long(obj1));
7795 if (SWIG_arg_fail(2)) SWIG_fail;
7796 }
7797 if (obj2) {
7798 {
7799 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7800 if (SWIG_arg_fail(3)) SWIG_fail;
7801 }
7802 }
7803 {
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7806
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 {
7811 resultobj = SWIG_From_long((long)(result));
7812 }
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7820 PyObject *resultobj;
7821 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7822 long result;
7823 PyObject * obj0 = 0 ;
7824 char *kwnames[] = {
7825 (char *) "self", NULL
7826 };
7827
7828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7830 if (SWIG_arg_fail(1)) SWIG_fail;
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 result = (long)(arg1)->TellI();
7834
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 {
7839 resultobj = SWIG_From_long((long)(result));
7840 }
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7848 PyObject *obj;
7849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7850 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7851 Py_INCREF(obj);
7852 return Py_BuildValue((char *)"");
7853 }
7854 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7855 PyObject *resultobj;
7856 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7857 PyObject *arg2 = (PyObject *) 0 ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 char *kwnames[] = {
7861 (char *) "self",(char *) "obj", NULL
7862 };
7863
7864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7866 if (SWIG_arg_fail(1)) SWIG_fail;
7867 arg2 = obj1;
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 wxOutputStream_write(arg1,arg2);
7871
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 Py_INCREF(Py_None); resultobj = Py_None;
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7883 PyObject *obj;
7884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7885 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7886 Py_INCREF(obj);
7887 return Py_BuildValue((char *)"");
7888 }
7889 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj;
7891 wxInputStream *arg1 = (wxInputStream *) 0 ;
7892 wxString *arg2 = 0 ;
7893 wxString *arg3 = 0 ;
7894 wxString *arg4 = 0 ;
7895 wxDateTime arg5 ;
7896 wxFSFile *result;
7897 wxPyInputStream *temp1 ;
7898 bool created1 ;
7899 bool temp2 = false ;
7900 bool temp3 = false ;
7901 bool temp4 = false ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 PyObject * obj2 = 0 ;
7905 PyObject * obj3 = 0 ;
7906 PyObject * obj4 = 0 ;
7907 char *kwnames[] = {
7908 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7909 };
7910
7911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7912 {
7913 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7914 arg1 = temp1->m_wxis;
7915 created1 = false;
7916 } else {
7917 PyErr_Clear(); // clear the failure of the wxPyConvert above
7918 arg1 = wxPyCBInputStream_create(obj0, false);
7919 if (arg1 == NULL) {
7920 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7921 SWIG_fail;
7922 }
7923 created1 = true;
7924 }
7925 }
7926 {
7927 arg2 = wxString_in_helper(obj1);
7928 if (arg2 == NULL) SWIG_fail;
7929 temp2 = true;
7930 }
7931 {
7932 arg3 = wxString_in_helper(obj2);
7933 if (arg3 == NULL) SWIG_fail;
7934 temp3 = true;
7935 }
7936 {
7937 arg4 = wxString_in_helper(obj3);
7938 if (arg4 == NULL) SWIG_fail;
7939 temp4 = true;
7940 }
7941 {
7942 wxDateTime * argp;
7943 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7944 if (SWIG_arg_fail(5)) SWIG_fail;
7945 if (argp == NULL) {
7946 SWIG_null_ref("wxDateTime");
7947 }
7948 if (SWIG_arg_fail(5)) SWIG_fail;
7949 arg5 = *argp;
7950 }
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7954
7955 wxPyEndAllowThreads(__tstate);
7956 if (PyErr_Occurred()) SWIG_fail;
7957 }
7958 {
7959 resultobj = wxPyMake_wxObject(result, 1);
7960 }
7961 {
7962 if (created1)
7963 delete arg1;
7964 }
7965 {
7966 if (temp2)
7967 delete arg2;
7968 }
7969 {
7970 if (temp3)
7971 delete arg3;
7972 }
7973 {
7974 if (temp4)
7975 delete arg4;
7976 }
7977 return resultobj;
7978 fail:
7979 {
7980 if (created1)
7981 delete arg1;
7982 }
7983 {
7984 if (temp2)
7985 delete arg2;
7986 }
7987 {
7988 if (temp3)
7989 delete arg3;
7990 }
7991 {
7992 if (temp4)
7993 delete arg4;
7994 }
7995 return NULL;
7996 }
7997
7998
7999 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj;
8001 wxFSFile *arg1 = (wxFSFile *) 0 ;
8002 PyObject * obj0 = 0 ;
8003 char *kwnames[] = {
8004 (char *) "self", NULL
8005 };
8006
8007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8009 if (SWIG_arg_fail(1)) SWIG_fail;
8010 {
8011 PyThreadState* __tstate = wxPyBeginAllowThreads();
8012 delete arg1;
8013
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 Py_INCREF(Py_None); resultobj = Py_None;
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8025 PyObject *resultobj;
8026 wxFSFile *arg1 = (wxFSFile *) 0 ;
8027 wxInputStream *result;
8028 PyObject * obj0 = 0 ;
8029 char *kwnames[] = {
8030 (char *) "self", NULL
8031 };
8032
8033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8035 if (SWIG_arg_fail(1)) SWIG_fail;
8036 {
8037 PyThreadState* __tstate = wxPyBeginAllowThreads();
8038 result = (wxInputStream *)(arg1)->GetStream();
8039
8040 wxPyEndAllowThreads(__tstate);
8041 if (PyErr_Occurred()) SWIG_fail;
8042 }
8043 {
8044 wxPyInputStream * _ptr = NULL;
8045
8046 if (result) {
8047 _ptr = new wxPyInputStream(result);
8048 }
8049 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8050 }
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj;
8059 wxFSFile *arg1 = (wxFSFile *) 0 ;
8060 wxString *result;
8061 PyObject * obj0 = 0 ;
8062 char *kwnames[] = {
8063 (char *) "self", NULL
8064 };
8065
8066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8068 if (SWIG_arg_fail(1)) SWIG_fail;
8069 {
8070 PyThreadState* __tstate = wxPyBeginAllowThreads();
8071 {
8072 wxString const &_result_ref = (arg1)->GetMimeType();
8073 result = (wxString *) &_result_ref;
8074 }
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 {
8080 #if wxUSE_UNICODE
8081 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8082 #else
8083 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8084 #endif
8085 }
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8093 PyObject *resultobj;
8094 wxFSFile *arg1 = (wxFSFile *) 0 ;
8095 wxString *result;
8096 PyObject * obj0 = 0 ;
8097 char *kwnames[] = {
8098 (char *) "self", NULL
8099 };
8100
8101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8103 if (SWIG_arg_fail(1)) SWIG_fail;
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 {
8107 wxString const &_result_ref = (arg1)->GetLocation();
8108 result = (wxString *) &_result_ref;
8109 }
8110
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 {
8115 #if wxUSE_UNICODE
8116 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8117 #else
8118 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8119 #endif
8120 }
8121 return resultobj;
8122 fail:
8123 return NULL;
8124 }
8125
8126
8127 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8128 PyObject *resultobj;
8129 wxFSFile *arg1 = (wxFSFile *) 0 ;
8130 wxString *result;
8131 PyObject * obj0 = 0 ;
8132 char *kwnames[] = {
8133 (char *) "self", NULL
8134 };
8135
8136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8138 if (SWIG_arg_fail(1)) SWIG_fail;
8139 {
8140 PyThreadState* __tstate = wxPyBeginAllowThreads();
8141 {
8142 wxString const &_result_ref = (arg1)->GetAnchor();
8143 result = (wxString *) &_result_ref;
8144 }
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 {
8150 #if wxUSE_UNICODE
8151 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8152 #else
8153 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8154 #endif
8155 }
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj;
8164 wxFSFile *arg1 = (wxFSFile *) 0 ;
8165 wxDateTime result;
8166 PyObject * obj0 = 0 ;
8167 char *kwnames[] = {
8168 (char *) "self", NULL
8169 };
8170
8171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8173 if (SWIG_arg_fail(1)) SWIG_fail;
8174 {
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (arg1)->GetModificationTime();
8177
8178 wxPyEndAllowThreads(__tstate);
8179 if (PyErr_Occurred()) SWIG_fail;
8180 }
8181 {
8182 wxDateTime * resultptr;
8183 resultptr = new wxDateTime((wxDateTime &)(result));
8184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8185 }
8186 return resultobj;
8187 fail:
8188 return NULL;
8189 }
8190
8191
8192 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8193 PyObject *obj;
8194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8195 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8196 Py_INCREF(obj);
8197 return Py_BuildValue((char *)"");
8198 }
8199 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8200 PyObject *obj;
8201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8202 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8203 Py_INCREF(obj);
8204 return Py_BuildValue((char *)"");
8205 }
8206 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8207 PyObject *resultobj;
8208 wxPyFileSystemHandler *result;
8209 char *kwnames[] = {
8210 NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8217
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj;
8230 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8231 PyObject *arg2 = (PyObject *) 0 ;
8232 PyObject *arg3 = (PyObject *) 0 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 PyObject * obj2 = 0 ;
8236 char *kwnames[] = {
8237 (char *) "self",(char *) "self",(char *) "_class", NULL
8238 };
8239
8240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8242 if (SWIG_arg_fail(1)) SWIG_fail;
8243 arg2 = obj1;
8244 arg3 = obj2;
8245 {
8246 PyThreadState* __tstate = wxPyBeginAllowThreads();
8247 (arg1)->_setCallbackInfo(arg2,arg3);
8248
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 Py_INCREF(Py_None); resultobj = Py_None;
8253 return resultobj;
8254 fail:
8255 return NULL;
8256 }
8257
8258
8259 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8260 PyObject *resultobj;
8261 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8262 wxString *arg2 = 0 ;
8263 bool result;
8264 bool temp2 = false ;
8265 PyObject * obj0 = 0 ;
8266 PyObject * obj1 = 0 ;
8267 char *kwnames[] = {
8268 (char *) "self",(char *) "location", NULL
8269 };
8270
8271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8273 if (SWIG_arg_fail(1)) SWIG_fail;
8274 {
8275 arg2 = wxString_in_helper(obj1);
8276 if (arg2 == NULL) SWIG_fail;
8277 temp2 = true;
8278 }
8279 {
8280 PyThreadState* __tstate = wxPyBeginAllowThreads();
8281 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8282
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 {
8287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8288 }
8289 {
8290 if (temp2)
8291 delete arg2;
8292 }
8293 return resultobj;
8294 fail:
8295 {
8296 if (temp2)
8297 delete arg2;
8298 }
8299 return NULL;
8300 }
8301
8302
8303 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj;
8305 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8306 wxFileSystem *arg2 = 0 ;
8307 wxString *arg3 = 0 ;
8308 wxFSFile *result;
8309 bool temp3 = false ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 PyObject * obj2 = 0 ;
8313 char *kwnames[] = {
8314 (char *) "self",(char *) "fs",(char *) "location", NULL
8315 };
8316
8317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8319 if (SWIG_arg_fail(1)) SWIG_fail;
8320 {
8321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8322 if (SWIG_arg_fail(2)) SWIG_fail;
8323 if (arg2 == NULL) {
8324 SWIG_null_ref("wxFileSystem");
8325 }
8326 if (SWIG_arg_fail(2)) SWIG_fail;
8327 }
8328 {
8329 arg3 = wxString_in_helper(obj2);
8330 if (arg3 == NULL) SWIG_fail;
8331 temp3 = true;
8332 }
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8336
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 {
8341 resultobj = wxPyMake_wxObject(result, 1);
8342 }
8343 {
8344 if (temp3)
8345 delete arg3;
8346 }
8347 return resultobj;
8348 fail:
8349 {
8350 if (temp3)
8351 delete arg3;
8352 }
8353 return NULL;
8354 }
8355
8356
8357 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj;
8359 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8360 wxString *arg2 = 0 ;
8361 int arg3 = (int) 0 ;
8362 wxString result;
8363 bool temp2 = false ;
8364 PyObject * obj0 = 0 ;
8365 PyObject * obj1 = 0 ;
8366 PyObject * obj2 = 0 ;
8367 char *kwnames[] = {
8368 (char *) "self",(char *) "spec",(char *) "flags", NULL
8369 };
8370
8371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8373 if (SWIG_arg_fail(1)) SWIG_fail;
8374 {
8375 arg2 = wxString_in_helper(obj1);
8376 if (arg2 == NULL) SWIG_fail;
8377 temp2 = true;
8378 }
8379 if (obj2) {
8380 {
8381 arg3 = (int)(SWIG_As_int(obj2));
8382 if (SWIG_arg_fail(3)) SWIG_fail;
8383 }
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 #if wxUSE_UNICODE
8394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8395 #else
8396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8397 #endif
8398 }
8399 {
8400 if (temp2)
8401 delete arg2;
8402 }
8403 return resultobj;
8404 fail:
8405 {
8406 if (temp2)
8407 delete arg2;
8408 }
8409 return NULL;
8410 }
8411
8412
8413 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj;
8415 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8416 wxString result;
8417 PyObject * obj0 = 0 ;
8418 char *kwnames[] = {
8419 (char *) "self", NULL
8420 };
8421
8422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(1)) SWIG_fail;
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 result = (arg1)->FindNext();
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 {
8433 #if wxUSE_UNICODE
8434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8435 #else
8436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8437 #endif
8438 }
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8446 PyObject *resultobj;
8447 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8448 wxString *arg2 = 0 ;
8449 wxString result;
8450 bool temp2 = false ;
8451 PyObject * obj0 = 0 ;
8452 PyObject * obj1 = 0 ;
8453 char *kwnames[] = {
8454 (char *) "self",(char *) "location", NULL
8455 };
8456
8457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8459 if (SWIG_arg_fail(1)) SWIG_fail;
8460 {
8461 arg2 = wxString_in_helper(obj1);
8462 if (arg2 == NULL) SWIG_fail;
8463 temp2 = true;
8464 }
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 result = (arg1)->GetProtocol((wxString const &)*arg2);
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 {
8473 #if wxUSE_UNICODE
8474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8475 #else
8476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8477 #endif
8478 }
8479 {
8480 if (temp2)
8481 delete arg2;
8482 }
8483 return resultobj;
8484 fail:
8485 {
8486 if (temp2)
8487 delete arg2;
8488 }
8489 return NULL;
8490 }
8491
8492
8493 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8494 PyObject *resultobj;
8495 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8496 wxString *arg2 = 0 ;
8497 wxString result;
8498 bool temp2 = false ;
8499 PyObject * obj0 = 0 ;
8500 PyObject * obj1 = 0 ;
8501 char *kwnames[] = {
8502 (char *) "self",(char *) "location", NULL
8503 };
8504
8505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8507 if (SWIG_arg_fail(1)) SWIG_fail;
8508 {
8509 arg2 = wxString_in_helper(obj1);
8510 if (arg2 == NULL) SWIG_fail;
8511 temp2 = true;
8512 }
8513 {
8514 PyThreadState* __tstate = wxPyBeginAllowThreads();
8515 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8516
8517 wxPyEndAllowThreads(__tstate);
8518 if (PyErr_Occurred()) SWIG_fail;
8519 }
8520 {
8521 #if wxUSE_UNICODE
8522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8523 #else
8524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8525 #endif
8526 }
8527 {
8528 if (temp2)
8529 delete arg2;
8530 }
8531 return resultobj;
8532 fail:
8533 {
8534 if (temp2)
8535 delete arg2;
8536 }
8537 return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8542 PyObject *resultobj;
8543 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8544 wxString *arg2 = 0 ;
8545 wxString result;
8546 bool temp2 = false ;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 char *kwnames[] = {
8550 (char *) "self",(char *) "location", NULL
8551 };
8552
8553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8555 if (SWIG_arg_fail(1)) SWIG_fail;
8556 {
8557 arg2 = wxString_in_helper(obj1);
8558 if (arg2 == NULL) SWIG_fail;
8559 temp2 = true;
8560 }
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->GetAnchor((wxString const &)*arg2);
8564
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 #if wxUSE_UNICODE
8570 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8571 #else
8572 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8573 #endif
8574 }
8575 {
8576 if (temp2)
8577 delete arg2;
8578 }
8579 return resultobj;
8580 fail:
8581 {
8582 if (temp2)
8583 delete arg2;
8584 }
8585 return NULL;
8586 }
8587
8588
8589 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8590 PyObject *resultobj;
8591 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8592 wxString *arg2 = 0 ;
8593 wxString result;
8594 bool temp2 = false ;
8595 PyObject * obj0 = 0 ;
8596 PyObject * obj1 = 0 ;
8597 char *kwnames[] = {
8598 (char *) "self",(char *) "location", NULL
8599 };
8600
8601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8603 if (SWIG_arg_fail(1)) SWIG_fail;
8604 {
8605 arg2 = wxString_in_helper(obj1);
8606 if (arg2 == NULL) SWIG_fail;
8607 temp2 = true;
8608 }
8609 {
8610 PyThreadState* __tstate = wxPyBeginAllowThreads();
8611 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8612
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 {
8617 #if wxUSE_UNICODE
8618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8619 #else
8620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8621 #endif
8622 }
8623 {
8624 if (temp2)
8625 delete arg2;
8626 }
8627 return resultobj;
8628 fail:
8629 {
8630 if (temp2)
8631 delete arg2;
8632 }
8633 return NULL;
8634 }
8635
8636
8637 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8638 PyObject *resultobj;
8639 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8640 wxString *arg2 = 0 ;
8641 wxString result;
8642 bool temp2 = false ;
8643 PyObject * obj0 = 0 ;
8644 PyObject * obj1 = 0 ;
8645 char *kwnames[] = {
8646 (char *) "self",(char *) "location", NULL
8647 };
8648
8649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8651 if (SWIG_arg_fail(1)) SWIG_fail;
8652 {
8653 arg2 = wxString_in_helper(obj1);
8654 if (arg2 == NULL) SWIG_fail;
8655 temp2 = true;
8656 }
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 {
8665 #if wxUSE_UNICODE
8666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8667 #else
8668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8669 #endif
8670 }
8671 {
8672 if (temp2)
8673 delete arg2;
8674 }
8675 return resultobj;
8676 fail:
8677 {
8678 if (temp2)
8679 delete arg2;
8680 }
8681 return NULL;
8682 }
8683
8684
8685 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8686 PyObject *obj;
8687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8688 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8689 Py_INCREF(obj);
8690 return Py_BuildValue((char *)"");
8691 }
8692 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8693 PyObject *resultobj;
8694 wxFileSystem *result;
8695 char *kwnames[] = {
8696 NULL
8697 };
8698
8699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8700 {
8701 PyThreadState* __tstate = wxPyBeginAllowThreads();
8702 result = (wxFileSystem *)new wxFileSystem();
8703
8704 wxPyEndAllowThreads(__tstate);
8705 if (PyErr_Occurred()) SWIG_fail;
8706 }
8707 {
8708 resultobj = wxPyMake_wxObject(result, 1);
8709 }
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8717 PyObject *resultobj;
8718 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8719 PyObject * obj0 = 0 ;
8720 char *kwnames[] = {
8721 (char *) "self", NULL
8722 };
8723
8724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 {
8728 PyThreadState* __tstate = wxPyBeginAllowThreads();
8729 delete arg1;
8730
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 Py_INCREF(Py_None); resultobj = Py_None;
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8742 PyObject *resultobj;
8743 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8744 wxString *arg2 = 0 ;
8745 bool arg3 = (bool) false ;
8746 bool temp2 = false ;
8747 PyObject * obj0 = 0 ;
8748 PyObject * obj1 = 0 ;
8749 PyObject * obj2 = 0 ;
8750 char *kwnames[] = {
8751 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8752 };
8753
8754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8756 if (SWIG_arg_fail(1)) SWIG_fail;
8757 {
8758 arg2 = wxString_in_helper(obj1);
8759 if (arg2 == NULL) SWIG_fail;
8760 temp2 = true;
8761 }
8762 if (obj2) {
8763 {
8764 arg3 = (bool)(SWIG_As_bool(obj2));
8765 if (SWIG_arg_fail(3)) SWIG_fail;
8766 }
8767 }
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 {
8777 if (temp2)
8778 delete arg2;
8779 }
8780 return resultobj;
8781 fail:
8782 {
8783 if (temp2)
8784 delete arg2;
8785 }
8786 return NULL;
8787 }
8788
8789
8790 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8791 PyObject *resultobj;
8792 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8793 wxString result;
8794 PyObject * obj0 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 {
8803 PyThreadState* __tstate = wxPyBeginAllowThreads();
8804 result = (arg1)->GetPath();
8805
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 {
8810 #if wxUSE_UNICODE
8811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8812 #else
8813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8814 #endif
8815 }
8816 return resultobj;
8817 fail:
8818 return NULL;
8819 }
8820
8821
8822 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8823 PyObject *resultobj;
8824 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8825 wxString *arg2 = 0 ;
8826 wxFSFile *result;
8827 bool temp2 = false ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 char *kwnames[] = {
8831 (char *) "self",(char *) "location", NULL
8832 };
8833
8834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8836 if (SWIG_arg_fail(1)) SWIG_fail;
8837 {
8838 arg2 = wxString_in_helper(obj1);
8839 if (arg2 == NULL) SWIG_fail;
8840 temp2 = true;
8841 }
8842 {
8843 PyThreadState* __tstate = wxPyBeginAllowThreads();
8844 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8845
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 {
8850 resultobj = wxPyMake_wxObject(result, 1);
8851 }
8852 {
8853 if (temp2)
8854 delete arg2;
8855 }
8856 return resultobj;
8857 fail:
8858 {
8859 if (temp2)
8860 delete arg2;
8861 }
8862 return NULL;
8863 }
8864
8865
8866 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj;
8868 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8869 wxString *arg2 = 0 ;
8870 int arg3 = (int) 0 ;
8871 wxString result;
8872 bool temp2 = false ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 PyObject * obj2 = 0 ;
8876 char *kwnames[] = {
8877 (char *) "self",(char *) "spec",(char *) "flags", NULL
8878 };
8879
8880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8882 if (SWIG_arg_fail(1)) SWIG_fail;
8883 {
8884 arg2 = wxString_in_helper(obj1);
8885 if (arg2 == NULL) SWIG_fail;
8886 temp2 = true;
8887 }
8888 if (obj2) {
8889 {
8890 arg3 = (int)(SWIG_As_int(obj2));
8891 if (SWIG_arg_fail(3)) SWIG_fail;
8892 }
8893 }
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 #if wxUSE_UNICODE
8903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8904 #else
8905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8906 #endif
8907 }
8908 {
8909 if (temp2)
8910 delete arg2;
8911 }
8912 return resultobj;
8913 fail:
8914 {
8915 if (temp2)
8916 delete arg2;
8917 }
8918 return NULL;
8919 }
8920
8921
8922 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj;
8924 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8925 wxString result;
8926 PyObject * obj0 = 0 ;
8927 char *kwnames[] = {
8928 (char *) "self", NULL
8929 };
8930
8931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8933 if (SWIG_arg_fail(1)) SWIG_fail;
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 result = (arg1)->FindNext();
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 {
8942 #if wxUSE_UNICODE
8943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8944 #else
8945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8946 #endif
8947 }
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8957 PyObject * obj0 = 0 ;
8958 char *kwnames[] = {
8959 (char *) "handler", NULL
8960 };
8961
8962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8964 if (SWIG_arg_fail(1)) SWIG_fail;
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 wxFileSystem::AddHandler(arg1);
8968
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 Py_INCREF(Py_None); resultobj = Py_None;
8973 return resultobj;
8974 fail:
8975 return NULL;
8976 }
8977
8978
8979 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8980 PyObject *resultobj;
8981 char *kwnames[] = {
8982 NULL
8983 };
8984
8985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 wxFileSystem::CleanUpHandlers();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 Py_INCREF(Py_None); resultobj = Py_None;
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj;
9002 wxString *arg1 = 0 ;
9003 wxString result;
9004 bool temp1 = false ;
9005 PyObject * obj0 = 0 ;
9006 char *kwnames[] = {
9007 (char *) "filename", NULL
9008 };
9009
9010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9011 {
9012 arg1 = wxString_in_helper(obj0);
9013 if (arg1 == NULL) SWIG_fail;
9014 temp1 = true;
9015 }
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9019
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 {
9024 #if wxUSE_UNICODE
9025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9026 #else
9027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9028 #endif
9029 }
9030 {
9031 if (temp1)
9032 delete arg1;
9033 }
9034 return resultobj;
9035 fail:
9036 {
9037 if (temp1)
9038 delete arg1;
9039 }
9040 return NULL;
9041 }
9042
9043
9044 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9045 PyObject *resultobj;
9046 wxString *arg1 = 0 ;
9047 wxString result;
9048 bool temp1 = false ;
9049 PyObject * obj0 = 0 ;
9050 char *kwnames[] = {
9051 (char *) "url", NULL
9052 };
9053
9054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9055 {
9056 arg1 = wxString_in_helper(obj0);
9057 if (arg1 == NULL) SWIG_fail;
9058 temp1 = true;
9059 }
9060 {
9061 PyThreadState* __tstate = wxPyBeginAllowThreads();
9062 result = FileSystem_URLToFileName((wxString const &)*arg1);
9063
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 {
9068 #if wxUSE_UNICODE
9069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9070 #else
9071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9072 #endif
9073 }
9074 {
9075 if (temp1)
9076 delete arg1;
9077 }
9078 return resultobj;
9079 fail:
9080 {
9081 if (temp1)
9082 delete arg1;
9083 }
9084 return NULL;
9085 }
9086
9087
9088 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9089 PyObject *obj;
9090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9091 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9092 Py_INCREF(obj);
9093 return Py_BuildValue((char *)"");
9094 }
9095 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9096 PyObject *resultobj;
9097 wxInternetFSHandler *result;
9098 char *kwnames[] = {
9099 NULL
9100 };
9101
9102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9106
9107 wxPyEndAllowThreads(__tstate);
9108 if (PyErr_Occurred()) SWIG_fail;
9109 }
9110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj;
9119 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9120 wxString *arg2 = 0 ;
9121 bool result;
9122 bool temp2 = false ;
9123 PyObject * obj0 = 0 ;
9124 PyObject * obj1 = 0 ;
9125 char *kwnames[] = {
9126 (char *) "self",(char *) "location", NULL
9127 };
9128
9129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9131 if (SWIG_arg_fail(1)) SWIG_fail;
9132 {
9133 arg2 = wxString_in_helper(obj1);
9134 if (arg2 == NULL) SWIG_fail;
9135 temp2 = true;
9136 }
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9140
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 {
9145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9146 }
9147 {
9148 if (temp2)
9149 delete arg2;
9150 }
9151 return resultobj;
9152 fail:
9153 {
9154 if (temp2)
9155 delete arg2;
9156 }
9157 return NULL;
9158 }
9159
9160
9161 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj;
9163 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9164 wxFileSystem *arg2 = 0 ;
9165 wxString *arg3 = 0 ;
9166 wxFSFile *result;
9167 bool temp3 = false ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 char *kwnames[] = {
9172 (char *) "self",(char *) "fs",(char *) "location", NULL
9173 };
9174
9175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9177 if (SWIG_arg_fail(1)) SWIG_fail;
9178 {
9179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9180 if (SWIG_arg_fail(2)) SWIG_fail;
9181 if (arg2 == NULL) {
9182 SWIG_null_ref("wxFileSystem");
9183 }
9184 if (SWIG_arg_fail(2)) SWIG_fail;
9185 }
9186 {
9187 arg3 = wxString_in_helper(obj2);
9188 if (arg3 == NULL) SWIG_fail;
9189 temp3 = true;
9190 }
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9194
9195 wxPyEndAllowThreads(__tstate);
9196 if (PyErr_Occurred()) SWIG_fail;
9197 }
9198 {
9199 resultobj = wxPyMake_wxObject(result, 1);
9200 }
9201 {
9202 if (temp3)
9203 delete arg3;
9204 }
9205 return resultobj;
9206 fail:
9207 {
9208 if (temp3)
9209 delete arg3;
9210 }
9211 return NULL;
9212 }
9213
9214
9215 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9216 PyObject *obj;
9217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9218 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9219 Py_INCREF(obj);
9220 return Py_BuildValue((char *)"");
9221 }
9222 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9223 PyObject *resultobj;
9224 wxZipFSHandler *result;
9225 char *kwnames[] = {
9226 NULL
9227 };
9228
9229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (wxZipFSHandler *)new wxZipFSHandler();
9233
9234 wxPyEndAllowThreads(__tstate);
9235 if (PyErr_Occurred()) SWIG_fail;
9236 }
9237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9238 return resultobj;
9239 fail:
9240 return NULL;
9241 }
9242
9243
9244 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9245 PyObject *resultobj;
9246 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9247 wxString *arg2 = 0 ;
9248 bool result;
9249 bool temp2 = false ;
9250 PyObject * obj0 = 0 ;
9251 PyObject * obj1 = 0 ;
9252 char *kwnames[] = {
9253 (char *) "self",(char *) "location", NULL
9254 };
9255
9256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9258 if (SWIG_arg_fail(1)) SWIG_fail;
9259 {
9260 arg2 = wxString_in_helper(obj1);
9261 if (arg2 == NULL) SWIG_fail;
9262 temp2 = true;
9263 }
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 {
9272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9273 }
9274 {
9275 if (temp2)
9276 delete arg2;
9277 }
9278 return resultobj;
9279 fail:
9280 {
9281 if (temp2)
9282 delete arg2;
9283 }
9284 return NULL;
9285 }
9286
9287
9288 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9289 PyObject *resultobj;
9290 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9291 wxFileSystem *arg2 = 0 ;
9292 wxString *arg3 = 0 ;
9293 wxFSFile *result;
9294 bool temp3 = false ;
9295 PyObject * obj0 = 0 ;
9296 PyObject * obj1 = 0 ;
9297 PyObject * obj2 = 0 ;
9298 char *kwnames[] = {
9299 (char *) "self",(char *) "fs",(char *) "location", NULL
9300 };
9301
9302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9304 if (SWIG_arg_fail(1)) SWIG_fail;
9305 {
9306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9307 if (SWIG_arg_fail(2)) SWIG_fail;
9308 if (arg2 == NULL) {
9309 SWIG_null_ref("wxFileSystem");
9310 }
9311 if (SWIG_arg_fail(2)) SWIG_fail;
9312 }
9313 {
9314 arg3 = wxString_in_helper(obj2);
9315 if (arg3 == NULL) SWIG_fail;
9316 temp3 = true;
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 {
9326 resultobj = wxPyMake_wxObject(result, 1);
9327 }
9328 {
9329 if (temp3)
9330 delete arg3;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp3)
9336 delete arg3;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9345 wxString *arg2 = 0 ;
9346 int arg3 = (int) 0 ;
9347 wxString result;
9348 bool temp2 = false ;
9349 PyObject * obj0 = 0 ;
9350 PyObject * obj1 = 0 ;
9351 PyObject * obj2 = 0 ;
9352 char *kwnames[] = {
9353 (char *) "self",(char *) "spec",(char *) "flags", NULL
9354 };
9355
9356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9358 if (SWIG_arg_fail(1)) SWIG_fail;
9359 {
9360 arg2 = wxString_in_helper(obj1);
9361 if (arg2 == NULL) SWIG_fail;
9362 temp2 = true;
9363 }
9364 if (obj2) {
9365 {
9366 arg3 = (int)(SWIG_As_int(obj2));
9367 if (SWIG_arg_fail(3)) SWIG_fail;
9368 }
9369 }
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 #if wxUSE_UNICODE
9379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9380 #else
9381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9382 #endif
9383 }
9384 {
9385 if (temp2)
9386 delete arg2;
9387 }
9388 return resultobj;
9389 fail:
9390 {
9391 if (temp2)
9392 delete arg2;
9393 }
9394 return NULL;
9395 }
9396
9397
9398 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj;
9400 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9401 wxString result;
9402 PyObject * obj0 = 0 ;
9403 char *kwnames[] = {
9404 (char *) "self", NULL
9405 };
9406
9407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9409 if (SWIG_arg_fail(1)) SWIG_fail;
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (arg1)->FindNext();
9413
9414 wxPyEndAllowThreads(__tstate);
9415 if (PyErr_Occurred()) SWIG_fail;
9416 }
9417 {
9418 #if wxUSE_UNICODE
9419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9420 #else
9421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9422 #endif
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9431 PyObject *obj;
9432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9433 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9434 Py_INCREF(obj);
9435 return Py_BuildValue((char *)"");
9436 }
9437 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj;
9439 wxString *arg1 = 0 ;
9440 wxImage *arg2 = 0 ;
9441 long arg3 ;
9442 bool temp1 = false ;
9443 PyObject * obj0 = 0 ;
9444 PyObject * obj1 = 0 ;
9445 PyObject * obj2 = 0 ;
9446 char *kwnames[] = {
9447 (char *) "filename",(char *) "image",(char *) "type", NULL
9448 };
9449
9450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9451 {
9452 arg1 = wxString_in_helper(obj0);
9453 if (arg1 == NULL) SWIG_fail;
9454 temp1 = true;
9455 }
9456 {
9457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9458 if (SWIG_arg_fail(2)) SWIG_fail;
9459 if (arg2 == NULL) {
9460 SWIG_null_ref("wxImage");
9461 }
9462 if (SWIG_arg_fail(2)) SWIG_fail;
9463 }
9464 {
9465 arg3 = (long)(SWIG_As_long(obj2));
9466 if (SWIG_arg_fail(3)) SWIG_fail;
9467 }
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9471
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 Py_INCREF(Py_None); resultobj = Py_None;
9476 {
9477 if (temp1)
9478 delete arg1;
9479 }
9480 return resultobj;
9481 fail:
9482 {
9483 if (temp1)
9484 delete arg1;
9485 }
9486 return NULL;
9487 }
9488
9489
9490 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9491 PyObject *resultobj;
9492 wxString *arg1 = 0 ;
9493 wxBitmap *arg2 = 0 ;
9494 long arg3 ;
9495 bool temp1 = false ;
9496 PyObject * obj0 = 0 ;
9497 PyObject * obj1 = 0 ;
9498 PyObject * obj2 = 0 ;
9499 char *kwnames[] = {
9500 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9501 };
9502
9503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9504 {
9505 arg1 = wxString_in_helper(obj0);
9506 if (arg1 == NULL) SWIG_fail;
9507 temp1 = true;
9508 }
9509 {
9510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9511 if (SWIG_arg_fail(2)) SWIG_fail;
9512 if (arg2 == NULL) {
9513 SWIG_null_ref("wxBitmap");
9514 }
9515 if (SWIG_arg_fail(2)) SWIG_fail;
9516 }
9517 {
9518 arg3 = (long)(SWIG_As_long(obj2));
9519 if (SWIG_arg_fail(3)) SWIG_fail;
9520 }
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9524
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 Py_INCREF(Py_None); resultobj = Py_None;
9529 {
9530 if (temp1)
9531 delete arg1;
9532 }
9533 return resultobj;
9534 fail:
9535 {
9536 if (temp1)
9537 delete arg1;
9538 }
9539 return NULL;
9540 }
9541
9542
9543 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxString *arg1 = 0 ;
9546 PyObject *arg2 = (PyObject *) 0 ;
9547 bool temp1 = false ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 char *kwnames[] = {
9551 (char *) "filename",(char *) "data", NULL
9552 };
9553
9554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9555 {
9556 arg1 = wxString_in_helper(obj0);
9557 if (arg1 == NULL) SWIG_fail;
9558 temp1 = true;
9559 }
9560 arg2 = obj1;
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9564
9565 wxPyEndAllowThreads(__tstate);
9566 if (PyErr_Occurred()) SWIG_fail;
9567 }
9568 Py_INCREF(Py_None); resultobj = Py_None;
9569 {
9570 if (temp1)
9571 delete arg1;
9572 }
9573 return resultobj;
9574 fail:
9575 {
9576 if (temp1)
9577 delete arg1;
9578 }
9579 return NULL;
9580 }
9581
9582
9583 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxMemoryFSHandler *result;
9586 char *kwnames[] = {
9587 NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9594
9595 wxPyEndAllowThreads(__tstate);
9596 if (PyErr_Occurred()) SWIG_fail;
9597 }
9598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9599 return resultobj;
9600 fail:
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxString *arg1 = 0 ;
9608 bool temp1 = false ;
9609 PyObject * obj0 = 0 ;
9610 char *kwnames[] = {
9611 (char *) "filename", NULL
9612 };
9613
9614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9615 {
9616 arg1 = wxString_in_helper(obj0);
9617 if (arg1 == NULL) SWIG_fail;
9618 temp1 = true;
9619 }
9620 {
9621 PyThreadState* __tstate = wxPyBeginAllowThreads();
9622 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9623
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 Py_INCREF(Py_None); resultobj = Py_None;
9628 {
9629 if (temp1)
9630 delete arg1;
9631 }
9632 return resultobj;
9633 fail:
9634 {
9635 if (temp1)
9636 delete arg1;
9637 }
9638 return NULL;
9639 }
9640
9641
9642 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9643 PyObject *resultobj;
9644 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9645 wxString *arg2 = 0 ;
9646 bool result;
9647 bool temp2 = false ;
9648 PyObject * obj0 = 0 ;
9649 PyObject * obj1 = 0 ;
9650 char *kwnames[] = {
9651 (char *) "self",(char *) "location", NULL
9652 };
9653
9654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9656 if (SWIG_arg_fail(1)) SWIG_fail;
9657 {
9658 arg2 = wxString_in_helper(obj1);
9659 if (arg2 == NULL) SWIG_fail;
9660 temp2 = true;
9661 }
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9665
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 {
9670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9671 }
9672 {
9673 if (temp2)
9674 delete arg2;
9675 }
9676 return resultobj;
9677 fail:
9678 {
9679 if (temp2)
9680 delete arg2;
9681 }
9682 return NULL;
9683 }
9684
9685
9686 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj;
9688 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9689 wxFileSystem *arg2 = 0 ;
9690 wxString *arg3 = 0 ;
9691 wxFSFile *result;
9692 bool temp3 = false ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 PyObject * obj2 = 0 ;
9696 char *kwnames[] = {
9697 (char *) "self",(char *) "fs",(char *) "location", NULL
9698 };
9699
9700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9702 if (SWIG_arg_fail(1)) SWIG_fail;
9703 {
9704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9705 if (SWIG_arg_fail(2)) SWIG_fail;
9706 if (arg2 == NULL) {
9707 SWIG_null_ref("wxFileSystem");
9708 }
9709 if (SWIG_arg_fail(2)) SWIG_fail;
9710 }
9711 {
9712 arg3 = wxString_in_helper(obj2);
9713 if (arg3 == NULL) SWIG_fail;
9714 temp3 = true;
9715 }
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 {
9724 resultobj = wxPyMake_wxObject(result, 1);
9725 }
9726 {
9727 if (temp3)
9728 delete arg3;
9729 }
9730 return resultobj;
9731 fail:
9732 {
9733 if (temp3)
9734 delete arg3;
9735 }
9736 return NULL;
9737 }
9738
9739
9740 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj;
9742 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9743 wxString *arg2 = 0 ;
9744 int arg3 = (int) 0 ;
9745 wxString result;
9746 bool temp2 = false ;
9747 PyObject * obj0 = 0 ;
9748 PyObject * obj1 = 0 ;
9749 PyObject * obj2 = 0 ;
9750 char *kwnames[] = {
9751 (char *) "self",(char *) "spec",(char *) "flags", NULL
9752 };
9753
9754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9756 if (SWIG_arg_fail(1)) SWIG_fail;
9757 {
9758 arg2 = wxString_in_helper(obj1);
9759 if (arg2 == NULL) SWIG_fail;
9760 temp2 = true;
9761 }
9762 if (obj2) {
9763 {
9764 arg3 = (int)(SWIG_As_int(obj2));
9765 if (SWIG_arg_fail(3)) SWIG_fail;
9766 }
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 #if wxUSE_UNICODE
9777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9778 #else
9779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9780 #endif
9781 }
9782 {
9783 if (temp2)
9784 delete arg2;
9785 }
9786 return resultobj;
9787 fail:
9788 {
9789 if (temp2)
9790 delete arg2;
9791 }
9792 return NULL;
9793 }
9794
9795
9796 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj;
9798 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9799 wxString result;
9800 PyObject * obj0 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "self", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (arg1)->FindNext();
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9829 PyObject *obj;
9830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9831 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9832 Py_INCREF(obj);
9833 return Py_BuildValue((char *)"");
9834 }
9835 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9836 PyObject *resultobj;
9837 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9838 wxString result;
9839 PyObject * obj0 = 0 ;
9840 char *kwnames[] = {
9841 (char *) "self", NULL
9842 };
9843
9844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9846 if (SWIG_arg_fail(1)) SWIG_fail;
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 result = (arg1)->GetName();
9850
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 {
9855 #if wxUSE_UNICODE
9856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9857 #else
9858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9859 #endif
9860 }
9861 return resultobj;
9862 fail:
9863 return NULL;
9864 }
9865
9866
9867 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9868 PyObject *resultobj;
9869 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9870 wxString result;
9871 PyObject * obj0 = 0 ;
9872 char *kwnames[] = {
9873 (char *) "self", NULL
9874 };
9875
9876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9878 if (SWIG_arg_fail(1)) SWIG_fail;
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (arg1)->GetExtension();
9882
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 {
9887 #if wxUSE_UNICODE
9888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9889 #else
9890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9891 #endif
9892 }
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj;
9901 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9902 long result;
9903 PyObject * obj0 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "self", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9910 if (SWIG_arg_fail(1)) SWIG_fail;
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (long)(arg1)->GetType();
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 {
9919 resultobj = SWIG_From_long((long)(result));
9920 }
9921 return resultobj;
9922 fail:
9923 return NULL;
9924 }
9925
9926
9927 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj;
9929 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9930 wxString result;
9931 PyObject * obj0 = 0 ;
9932 char *kwnames[] = {
9933 (char *) "self", NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9938 if (SWIG_arg_fail(1)) SWIG_fail;
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 result = (arg1)->GetMimeType();
9942
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 {
9947 #if wxUSE_UNICODE
9948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9949 #else
9950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9951 #endif
9952 }
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj;
9961 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9962 wxString *arg2 = 0 ;
9963 bool result;
9964 bool temp2 = false ;
9965 PyObject * obj0 = 0 ;
9966 PyObject * obj1 = 0 ;
9967 char *kwnames[] = {
9968 (char *) "self",(char *) "name", NULL
9969 };
9970
9971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9973 if (SWIG_arg_fail(1)) SWIG_fail;
9974 {
9975 arg2 = wxString_in_helper(obj1);
9976 if (arg2 == NULL) SWIG_fail;
9977 temp2 = true;
9978 }
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9982
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 {
9987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9988 }
9989 {
9990 if (temp2)
9991 delete arg2;
9992 }
9993 return resultobj;
9994 fail:
9995 {
9996 if (temp2)
9997 delete arg2;
9998 }
9999 return NULL;
10000 }
10001
10002
10003 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10004 PyObject *resultobj;
10005 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10006 wxString *arg2 = 0 ;
10007 bool temp2 = false ;
10008 PyObject * obj0 = 0 ;
10009 PyObject * obj1 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "self",(char *) "name", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10016 if (SWIG_arg_fail(1)) SWIG_fail;
10017 {
10018 arg2 = wxString_in_helper(obj1);
10019 if (arg2 == NULL) SWIG_fail;
10020 temp2 = true;
10021 }
10022 {
10023 PyThreadState* __tstate = wxPyBeginAllowThreads();
10024 (arg1)->SetName((wxString const &)*arg2);
10025
10026 wxPyEndAllowThreads(__tstate);
10027 if (PyErr_Occurred()) SWIG_fail;
10028 }
10029 Py_INCREF(Py_None); resultobj = Py_None;
10030 {
10031 if (temp2)
10032 delete arg2;
10033 }
10034 return resultobj;
10035 fail:
10036 {
10037 if (temp2)
10038 delete arg2;
10039 }
10040 return NULL;
10041 }
10042
10043
10044 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj;
10046 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10047 wxString *arg2 = 0 ;
10048 bool temp2 = false ;
10049 PyObject * obj0 = 0 ;
10050 PyObject * obj1 = 0 ;
10051 char *kwnames[] = {
10052 (char *) "self",(char *) "extension", NULL
10053 };
10054
10055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10057 if (SWIG_arg_fail(1)) SWIG_fail;
10058 {
10059 arg2 = wxString_in_helper(obj1);
10060 if (arg2 == NULL) SWIG_fail;
10061 temp2 = true;
10062 }
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 (arg1)->SetExtension((wxString const &)*arg2);
10066
10067 wxPyEndAllowThreads(__tstate);
10068 if (PyErr_Occurred()) SWIG_fail;
10069 }
10070 Py_INCREF(Py_None); resultobj = Py_None;
10071 {
10072 if (temp2)
10073 delete arg2;
10074 }
10075 return resultobj;
10076 fail:
10077 {
10078 if (temp2)
10079 delete arg2;
10080 }
10081 return NULL;
10082 }
10083
10084
10085 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj;
10087 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10088 long arg2 ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 char *kwnames[] = {
10092 (char *) "self",(char *) "type", NULL
10093 };
10094
10095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10097 if (SWIG_arg_fail(1)) SWIG_fail;
10098 {
10099 arg2 = (long)(SWIG_As_long(obj1));
10100 if (SWIG_arg_fail(2)) SWIG_fail;
10101 }
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 (arg1)->SetType(arg2);
10105
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 Py_INCREF(Py_None); resultobj = Py_None;
10110 return resultobj;
10111 fail:
10112 return NULL;
10113 }
10114
10115
10116 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10117 PyObject *resultobj;
10118 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10119 wxString *arg2 = 0 ;
10120 bool temp2 = false ;
10121 PyObject * obj0 = 0 ;
10122 PyObject * obj1 = 0 ;
10123 char *kwnames[] = {
10124 (char *) "self",(char *) "mimetype", NULL
10125 };
10126
10127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10129 if (SWIG_arg_fail(1)) SWIG_fail;
10130 {
10131 arg2 = wxString_in_helper(obj1);
10132 if (arg2 == NULL) SWIG_fail;
10133 temp2 = true;
10134 }
10135 {
10136 PyThreadState* __tstate = wxPyBeginAllowThreads();
10137 (arg1)->SetMimeType((wxString const &)*arg2);
10138
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 Py_INCREF(Py_None); resultobj = Py_None;
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return resultobj;
10148 fail:
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return NULL;
10154 }
10155
10156
10157 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10158 PyObject *obj;
10159 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10160 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10161 Py_INCREF(obj);
10162 return Py_BuildValue((char *)"");
10163 }
10164 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10165 PyObject *resultobj;
10166 wxImageHistogram *result;
10167 char *kwnames[] = {
10168 NULL
10169 };
10170
10171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10172 {
10173 PyThreadState* __tstate = wxPyBeginAllowThreads();
10174 result = (wxImageHistogram *)new wxImageHistogram();
10175
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10180 return resultobj;
10181 fail:
10182 return NULL;
10183 }
10184
10185
10186 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj;
10188 unsigned char arg1 ;
10189 unsigned char arg2 ;
10190 unsigned char arg3 ;
10191 unsigned long result;
10192 PyObject * obj0 = 0 ;
10193 PyObject * obj1 = 0 ;
10194 PyObject * obj2 = 0 ;
10195 char *kwnames[] = {
10196 (char *) "r",(char *) "g",(char *) "b", NULL
10197 };
10198
10199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10200 {
10201 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10202 if (SWIG_arg_fail(1)) SWIG_fail;
10203 }
10204 {
10205 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10206 if (SWIG_arg_fail(2)) SWIG_fail;
10207 }
10208 {
10209 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10210 if (SWIG_arg_fail(3)) SWIG_fail;
10211 }
10212 {
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10215
10216 wxPyEndAllowThreads(__tstate);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 {
10220 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10221 }
10222 return resultobj;
10223 fail:
10224 return NULL;
10225 }
10226
10227
10228 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj;
10230 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10231 unsigned char *arg2 = (unsigned char *) 0 ;
10232 unsigned char *arg3 = (unsigned char *) 0 ;
10233 unsigned char *arg4 = (unsigned char *) 0 ;
10234 unsigned char arg5 = (unsigned char) 1 ;
10235 unsigned char arg6 = (unsigned char) 0 ;
10236 unsigned char arg7 = (unsigned char) 0 ;
10237 bool result;
10238 unsigned char temp2 ;
10239 int res2 = 0 ;
10240 unsigned char temp3 ;
10241 int res3 = 0 ;
10242 unsigned char temp4 ;
10243 int res4 = 0 ;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 PyObject * obj3 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10250 };
10251
10252 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10253 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10254 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10257 if (SWIG_arg_fail(1)) SWIG_fail;
10258 if (obj1) {
10259 {
10260 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10261 if (SWIG_arg_fail(5)) SWIG_fail;
10262 }
10263 }
10264 if (obj2) {
10265 {
10266 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10267 if (SWIG_arg_fail(6)) SWIG_fail;
10268 }
10269 }
10270 if (obj3) {
10271 {
10272 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10273 if (SWIG_arg_fail(7)) SWIG_fail;
10274 }
10275 }
10276 {
10277 PyThreadState* __tstate = wxPyBeginAllowThreads();
10278 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10279
10280 wxPyEndAllowThreads(__tstate);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 {
10284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10285 }
10286 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10287 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10288 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10289 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10290 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10291 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10292 return resultobj;
10293 fail:
10294 return NULL;
10295 }
10296
10297
10298 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10299 PyObject *obj;
10300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10301 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10302 Py_INCREF(obj);
10303 return Py_BuildValue((char *)"");
10304 }
10305 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj;
10307 wxString *arg1 = 0 ;
10308 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10309 int arg3 = (int) -1 ;
10310 wxImage *result;
10311 bool temp1 = false ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 PyObject * obj2 = 0 ;
10315 char *kwnames[] = {
10316 (char *) "name",(char *) "type",(char *) "index", NULL
10317 };
10318
10319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10320 {
10321 arg1 = wxString_in_helper(obj0);
10322 if (arg1 == NULL) SWIG_fail;
10323 temp1 = true;
10324 }
10325 if (obj1) {
10326 {
10327 arg2 = (long)(SWIG_As_long(obj1));
10328 if (SWIG_arg_fail(2)) SWIG_fail;
10329 }
10330 }
10331 if (obj2) {
10332 {
10333 arg3 = (int)(SWIG_As_int(obj2));
10334 if (SWIG_arg_fail(3)) SWIG_fail;
10335 }
10336 }
10337 {
10338 PyThreadState* __tstate = wxPyBeginAllowThreads();
10339 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10340
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10345 {
10346 if (temp1)
10347 delete arg1;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp1)
10353 delete arg1;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj;
10361 wxImage *arg1 = (wxImage *) 0 ;
10362 PyObject * obj0 = 0 ;
10363 char *kwnames[] = {
10364 (char *) "self", NULL
10365 };
10366
10367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10369 if (SWIG_arg_fail(1)) SWIG_fail;
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 delete arg1;
10373
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 Py_INCREF(Py_None); resultobj = Py_None;
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxString *arg1 = 0 ;
10387 wxString *arg2 = 0 ;
10388 int arg3 = (int) -1 ;
10389 wxImage *result;
10390 bool temp1 = false ;
10391 bool temp2 = false ;
10392 PyObject * obj0 = 0 ;
10393 PyObject * obj1 = 0 ;
10394 PyObject * obj2 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10400 {
10401 arg1 = wxString_in_helper(obj0);
10402 if (arg1 == NULL) SWIG_fail;
10403 temp1 = true;
10404 }
10405 {
10406 arg2 = wxString_in_helper(obj1);
10407 if (arg2 == NULL) SWIG_fail;
10408 temp2 = true;
10409 }
10410 if (obj2) {
10411 {
10412 arg3 = (int)(SWIG_As_int(obj2));
10413 if (SWIG_arg_fail(3)) SWIG_fail;
10414 }
10415 }
10416 {
10417 PyThreadState* __tstate = wxPyBeginAllowThreads();
10418 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10419
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10424 {
10425 if (temp1)
10426 delete arg1;
10427 }
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return resultobj;
10433 fail:
10434 {
10435 if (temp1)
10436 delete arg1;
10437 }
10438 {
10439 if (temp2)
10440 delete arg2;
10441 }
10442 return NULL;
10443 }
10444
10445
10446 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj;
10448 wxInputStream *arg1 = 0 ;
10449 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10450 int arg3 = (int) -1 ;
10451 wxImage *result;
10452 wxPyInputStream *temp1 ;
10453 bool created1 ;
10454 PyObject * obj0 = 0 ;
10455 PyObject * obj1 = 0 ;
10456 PyObject * obj2 = 0 ;
10457 char *kwnames[] = {
10458 (char *) "stream",(char *) "type",(char *) "index", NULL
10459 };
10460
10461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10462 {
10463 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10464 arg1 = temp1->m_wxis;
10465 created1 = false;
10466 } else {
10467 PyErr_Clear(); // clear the failure of the wxPyConvert above
10468 arg1 = wxPyCBInputStream_create(obj0, false);
10469 if (arg1 == NULL) {
10470 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10471 SWIG_fail;
10472 }
10473 created1 = true;
10474 }
10475 }
10476 if (obj1) {
10477 {
10478 arg2 = (long)(SWIG_As_long(obj1));
10479 if (SWIG_arg_fail(2)) SWIG_fail;
10480 }
10481 }
10482 if (obj2) {
10483 {
10484 arg3 = (int)(SWIG_As_int(obj2));
10485 if (SWIG_arg_fail(3)) SWIG_fail;
10486 }
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10496 {
10497 if (created1)
10498 delete arg1;
10499 }
10500 return resultobj;
10501 fail:
10502 {
10503 if (created1)
10504 delete arg1;
10505 }
10506 return NULL;
10507 }
10508
10509
10510 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10511 PyObject *resultobj;
10512 wxInputStream *arg1 = 0 ;
10513 wxString *arg2 = 0 ;
10514 int arg3 = (int) -1 ;
10515 wxImage *result;
10516 wxPyInputStream *temp1 ;
10517 bool created1 ;
10518 bool temp2 = false ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521 PyObject * obj2 = 0 ;
10522 char *kwnames[] = {
10523 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10524 };
10525
10526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10527 {
10528 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10529 arg1 = temp1->m_wxis;
10530 created1 = false;
10531 } else {
10532 PyErr_Clear(); // clear the failure of the wxPyConvert above
10533 arg1 = wxPyCBInputStream_create(obj0, false);
10534 if (arg1 == NULL) {
10535 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10536 SWIG_fail;
10537 }
10538 created1 = true;
10539 }
10540 }
10541 {
10542 arg2 = wxString_in_helper(obj1);
10543 if (arg2 == NULL) SWIG_fail;
10544 temp2 = true;
10545 }
10546 if (obj2) {
10547 {
10548 arg3 = (int)(SWIG_As_int(obj2));
10549 if (SWIG_arg_fail(3)) SWIG_fail;
10550 }
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10555
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10560 {
10561 if (created1)
10562 delete arg1;
10563 }
10564 {
10565 if (temp2)
10566 delete arg2;
10567 }
10568 return resultobj;
10569 fail:
10570 {
10571 if (created1)
10572 delete arg1;
10573 }
10574 {
10575 if (temp2)
10576 delete arg2;
10577 }
10578 return NULL;
10579 }
10580
10581
10582 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10583 PyObject *resultobj;
10584 int arg1 = (int) 0 ;
10585 int arg2 = (int) 0 ;
10586 bool arg3 = (bool) true ;
10587 wxImage *result;
10588 PyObject * obj0 = 0 ;
10589 PyObject * obj1 = 0 ;
10590 PyObject * obj2 = 0 ;
10591 char *kwnames[] = {
10592 (char *) "width",(char *) "height",(char *) "clear", NULL
10593 };
10594
10595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10596 if (obj0) {
10597 {
10598 arg1 = (int)(SWIG_As_int(obj0));
10599 if (SWIG_arg_fail(1)) SWIG_fail;
10600 }
10601 }
10602 if (obj1) {
10603 {
10604 arg2 = (int)(SWIG_As_int(obj1));
10605 if (SWIG_arg_fail(2)) SWIG_fail;
10606 }
10607 }
10608 if (obj2) {
10609 {
10610 arg3 = (bool)(SWIG_As_bool(obj2));
10611 if (SWIG_arg_fail(3)) SWIG_fail;
10612 }
10613 }
10614 {
10615 PyThreadState* __tstate = wxPyBeginAllowThreads();
10616 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10617
10618 wxPyEndAllowThreads(__tstate);
10619 if (PyErr_Occurred()) SWIG_fail;
10620 }
10621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10622 return resultobj;
10623 fail:
10624 return NULL;
10625 }
10626
10627
10628 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10629 PyObject *resultobj;
10630 wxBitmap *arg1 = 0 ;
10631 wxImage *result;
10632 PyObject * obj0 = 0 ;
10633 char *kwnames[] = {
10634 (char *) "bitmap", NULL
10635 };
10636
10637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10638 {
10639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10640 if (SWIG_arg_fail(1)) SWIG_fail;
10641 if (arg1 == NULL) {
10642 SWIG_null_ref("wxBitmap");
10643 }
10644 if (SWIG_arg_fail(1)) SWIG_fail;
10645 }
10646 {
10647 if (!wxPyCheckForApp()) SWIG_fail;
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10650
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10655 return resultobj;
10656 fail:
10657 return NULL;
10658 }
10659
10660
10661 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10662 PyObject *resultobj;
10663 int arg1 ;
10664 int arg2 ;
10665 unsigned char *arg3 = (unsigned char *) 0 ;
10666 wxImage *result;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 PyObject * obj2 = 0 ;
10670 char *kwnames[] = {
10671 (char *) "width",(char *) "height",(char *) "data", NULL
10672 };
10673
10674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10675 {
10676 arg1 = (int)(SWIG_As_int(obj0));
10677 if (SWIG_arg_fail(1)) SWIG_fail;
10678 }
10679 {
10680 arg2 = (int)(SWIG_As_int(obj1));
10681 if (SWIG_arg_fail(2)) SWIG_fail;
10682 }
10683 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10684 if (SWIG_arg_fail(3)) SWIG_fail;
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10688
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 int arg1 ;
10702 int arg2 ;
10703 unsigned char *arg3 = (unsigned char *) 0 ;
10704 unsigned char *arg4 = (unsigned char *) 0 ;
10705 wxImage *result;
10706 PyObject * obj0 = 0 ;
10707 PyObject * obj1 = 0 ;
10708 PyObject * obj2 = 0 ;
10709 PyObject * obj3 = 0 ;
10710 char *kwnames[] = {
10711 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10712 };
10713
10714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10715 {
10716 arg1 = (int)(SWIG_As_int(obj0));
10717 if (SWIG_arg_fail(1)) SWIG_fail;
10718 }
10719 {
10720 arg2 = (int)(SWIG_As_int(obj1));
10721 if (SWIG_arg_fail(2)) SWIG_fail;
10722 }
10723 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10724 if (SWIG_arg_fail(3)) SWIG_fail;
10725 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10726 if (SWIG_arg_fail(4)) SWIG_fail;
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj;
10743 wxImage *arg1 = (wxImage *) 0 ;
10744 int arg2 ;
10745 int arg3 ;
10746 PyObject * obj0 = 0 ;
10747 PyObject * obj1 = 0 ;
10748 PyObject * obj2 = 0 ;
10749 char *kwnames[] = {
10750 (char *) "self",(char *) "width",(char *) "height", NULL
10751 };
10752
10753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 {
10757 arg2 = (int)(SWIG_As_int(obj1));
10758 if (SWIG_arg_fail(2)) SWIG_fail;
10759 }
10760 {
10761 arg3 = (int)(SWIG_As_int(obj2));
10762 if (SWIG_arg_fail(3)) SWIG_fail;
10763 }
10764 {
10765 PyThreadState* __tstate = wxPyBeginAllowThreads();
10766 (arg1)->Create(arg2,arg3);
10767
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 Py_INCREF(Py_None); resultobj = Py_None;
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj;
10780 wxImage *arg1 = (wxImage *) 0 ;
10781 PyObject * obj0 = 0 ;
10782 char *kwnames[] = {
10783 (char *) "self", NULL
10784 };
10785
10786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10788 if (SWIG_arg_fail(1)) SWIG_fail;
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 (arg1)->Destroy();
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 Py_INCREF(Py_None); resultobj = Py_None;
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj;
10805 wxImage *arg1 = (wxImage *) 0 ;
10806 int arg2 ;
10807 int arg3 ;
10808 SwigValueWrapper<wxImage > result;
10809 PyObject * obj0 = 0 ;
10810 PyObject * obj1 = 0 ;
10811 PyObject * obj2 = 0 ;
10812 char *kwnames[] = {
10813 (char *) "self",(char *) "width",(char *) "height", NULL
10814 };
10815
10816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10818 if (SWIG_arg_fail(1)) SWIG_fail;
10819 {
10820 arg2 = (int)(SWIG_As_int(obj1));
10821 if (SWIG_arg_fail(2)) SWIG_fail;
10822 }
10823 {
10824 arg3 = (int)(SWIG_As_int(obj2));
10825 if (SWIG_arg_fail(3)) SWIG_fail;
10826 }
10827 {
10828 PyThreadState* __tstate = wxPyBeginAllowThreads();
10829 result = (arg1)->Scale(arg2,arg3);
10830
10831 wxPyEndAllowThreads(__tstate);
10832 if (PyErr_Occurred()) SWIG_fail;
10833 }
10834 {
10835 wxImage * resultptr;
10836 resultptr = new wxImage((wxImage &)(result));
10837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10838 }
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10846 PyObject *resultobj;
10847 wxImage *arg1 = (wxImage *) 0 ;
10848 int arg2 ;
10849 int arg3 ;
10850 SwigValueWrapper<wxImage > result;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 PyObject * obj2 = 0 ;
10854 char *kwnames[] = {
10855 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10860 if (SWIG_arg_fail(1)) SWIG_fail;
10861 {
10862 arg2 = (int)(SWIG_As_int(obj1));
10863 if (SWIG_arg_fail(2)) SWIG_fail;
10864 }
10865 {
10866 arg3 = (int)(SWIG_As_int(obj2));
10867 if (SWIG_arg_fail(3)) SWIG_fail;
10868 }
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10872
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 {
10877 wxImage * resultptr;
10878 resultptr = new wxImage((wxImage &)(result));
10879 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10880 }
10881 return resultobj;
10882 fail:
10883 return NULL;
10884 }
10885
10886
10887 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10888 PyObject *resultobj;
10889 wxImage *arg1 = (wxImage *) 0 ;
10890 int arg2 ;
10891 int arg3 ;
10892 wxImage *result;
10893 PyObject * obj0 = 0 ;
10894 PyObject * obj1 = 0 ;
10895 PyObject * obj2 = 0 ;
10896 char *kwnames[] = {
10897 (char *) "self",(char *) "width",(char *) "height", NULL
10898 };
10899
10900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10902 if (SWIG_arg_fail(1)) SWIG_fail;
10903 {
10904 arg2 = (int)(SWIG_As_int(obj1));
10905 if (SWIG_arg_fail(2)) SWIG_fail;
10906 }
10907 {
10908 arg3 = (int)(SWIG_As_int(obj2));
10909 if (SWIG_arg_fail(3)) SWIG_fail;
10910 }
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 {
10914 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10915 result = (wxImage *) &_result_ref;
10916 }
10917
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10922 return resultobj;
10923 fail:
10924 return NULL;
10925 }
10926
10927
10928 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10929 PyObject *resultobj;
10930 wxImage *arg1 = (wxImage *) 0 ;
10931 int arg2 ;
10932 int arg3 ;
10933 unsigned char arg4 ;
10934 unsigned char arg5 ;
10935 unsigned char arg6 ;
10936 PyObject * obj0 = 0 ;
10937 PyObject * obj1 = 0 ;
10938 PyObject * obj2 = 0 ;
10939 PyObject * obj3 = 0 ;
10940 PyObject * obj4 = 0 ;
10941 PyObject * obj5 = 0 ;
10942 char *kwnames[] = {
10943 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10944 };
10945
10946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10948 if (SWIG_arg_fail(1)) SWIG_fail;
10949 {
10950 arg2 = (int)(SWIG_As_int(obj1));
10951 if (SWIG_arg_fail(2)) SWIG_fail;
10952 }
10953 {
10954 arg3 = (int)(SWIG_As_int(obj2));
10955 if (SWIG_arg_fail(3)) SWIG_fail;
10956 }
10957 {
10958 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10959 if (SWIG_arg_fail(4)) SWIG_fail;
10960 }
10961 {
10962 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10963 if (SWIG_arg_fail(5)) SWIG_fail;
10964 }
10965 {
10966 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10967 if (SWIG_arg_fail(6)) SWIG_fail;
10968 }
10969 {
10970 PyThreadState* __tstate = wxPyBeginAllowThreads();
10971 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10972
10973 wxPyEndAllowThreads(__tstate);
10974 if (PyErr_Occurred()) SWIG_fail;
10975 }
10976 Py_INCREF(Py_None); resultobj = Py_None;
10977 return resultobj;
10978 fail:
10979 return NULL;
10980 }
10981
10982
10983 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10984 PyObject *resultobj;
10985 wxImage *arg1 = (wxImage *) 0 ;
10986 int arg2 ;
10987 int arg3 ;
10988 unsigned char result;
10989 PyObject * obj0 = 0 ;
10990 PyObject * obj1 = 0 ;
10991 PyObject * obj2 = 0 ;
10992 char *kwnames[] = {
10993 (char *) "self",(char *) "x",(char *) "y", NULL
10994 };
10995
10996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(1)) SWIG_fail;
10999 {
11000 arg2 = (int)(SWIG_As_int(obj1));
11001 if (SWIG_arg_fail(2)) SWIG_fail;
11002 }
11003 {
11004 arg3 = (int)(SWIG_As_int(obj2));
11005 if (SWIG_arg_fail(3)) SWIG_fail;
11006 }
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11010
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 {
11015 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11016 }
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj;
11025 wxImage *arg1 = (wxImage *) 0 ;
11026 int arg2 ;
11027 int arg3 ;
11028 unsigned char result;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 PyObject * obj2 = 0 ;
11032 char *kwnames[] = {
11033 (char *) "self",(char *) "x",(char *) "y", NULL
11034 };
11035
11036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11038 if (SWIG_arg_fail(1)) SWIG_fail;
11039 {
11040 arg2 = (int)(SWIG_As_int(obj1));
11041 if (SWIG_arg_fail(2)) SWIG_fail;
11042 }
11043 {
11044 arg3 = (int)(SWIG_As_int(obj2));
11045 if (SWIG_arg_fail(3)) SWIG_fail;
11046 }
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11050
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11056 }
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj;
11065 wxImage *arg1 = (wxImage *) 0 ;
11066 int arg2 ;
11067 int arg3 ;
11068 unsigned char result;
11069 PyObject * obj0 = 0 ;
11070 PyObject * obj1 = 0 ;
11071 PyObject * obj2 = 0 ;
11072 char *kwnames[] = {
11073 (char *) "self",(char *) "x",(char *) "y", NULL
11074 };
11075
11076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11078 if (SWIG_arg_fail(1)) SWIG_fail;
11079 {
11080 arg2 = (int)(SWIG_As_int(obj1));
11081 if (SWIG_arg_fail(2)) SWIG_fail;
11082 }
11083 {
11084 arg3 = (int)(SWIG_As_int(obj2));
11085 if (SWIG_arg_fail(3)) SWIG_fail;
11086 }
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11090
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11096 }
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11104 PyObject *resultobj;
11105 wxImage *arg1 = (wxImage *) 0 ;
11106 int arg2 ;
11107 int arg3 ;
11108 unsigned char arg4 ;
11109 PyObject * obj0 = 0 ;
11110 PyObject * obj1 = 0 ;
11111 PyObject * obj2 = 0 ;
11112 PyObject * obj3 = 0 ;
11113 char *kwnames[] = {
11114 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11115 };
11116
11117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11119 if (SWIG_arg_fail(1)) SWIG_fail;
11120 {
11121 arg2 = (int)(SWIG_As_int(obj1));
11122 if (SWIG_arg_fail(2)) SWIG_fail;
11123 }
11124 {
11125 arg3 = (int)(SWIG_As_int(obj2));
11126 if (SWIG_arg_fail(3)) SWIG_fail;
11127 }
11128 {
11129 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11130 if (SWIG_arg_fail(4)) SWIG_fail;
11131 }
11132 {
11133 PyThreadState* __tstate = wxPyBeginAllowThreads();
11134 (arg1)->SetAlpha(arg2,arg3,arg4);
11135
11136 wxPyEndAllowThreads(__tstate);
11137 if (PyErr_Occurred()) SWIG_fail;
11138 }
11139 Py_INCREF(Py_None); resultobj = Py_None;
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxImage *arg1 = (wxImage *) 0 ;
11149 int arg2 ;
11150 int arg3 ;
11151 unsigned char result;
11152 PyObject * obj0 = 0 ;
11153 PyObject * obj1 = 0 ;
11154 PyObject * obj2 = 0 ;
11155 char *kwnames[] = {
11156 (char *) "self",(char *) "x",(char *) "y", NULL
11157 };
11158
11159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11161 if (SWIG_arg_fail(1)) SWIG_fail;
11162 {
11163 arg2 = (int)(SWIG_As_int(obj1));
11164 if (SWIG_arg_fail(2)) SWIG_fail;
11165 }
11166 {
11167 arg3 = (int)(SWIG_As_int(obj2));
11168 if (SWIG_arg_fail(3)) SWIG_fail;
11169 }
11170 {
11171 PyThreadState* __tstate = wxPyBeginAllowThreads();
11172 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11173
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 {
11178 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11179 }
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11187 PyObject *resultobj;
11188 wxImage *arg1 = (wxImage *) 0 ;
11189 bool result;
11190 PyObject * obj0 = 0 ;
11191 char *kwnames[] = {
11192 (char *) "self", NULL
11193 };
11194
11195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11197 if (SWIG_arg_fail(1)) SWIG_fail;
11198 {
11199 PyThreadState* __tstate = wxPyBeginAllowThreads();
11200 result = (bool)(arg1)->HasAlpha();
11201
11202 wxPyEndAllowThreads(__tstate);
11203 if (PyErr_Occurred()) SWIG_fail;
11204 }
11205 {
11206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11207 }
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj;
11216 wxImage *arg1 = (wxImage *) 0 ;
11217 PyObject * obj0 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "self", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11224 if (SWIG_arg_fail(1)) SWIG_fail;
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 (arg1)->InitAlpha();
11228
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 Py_INCREF(Py_None); resultobj = Py_None;
11233 return resultobj;
11234 fail:
11235 return NULL;
11236 }
11237
11238
11239 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11240 PyObject *resultobj;
11241 wxImage *arg1 = (wxImage *) 0 ;
11242 byte *arg2 = (byte *) 0 ;
11243 byte *arg3 = (byte *) 0 ;
11244 byte *arg4 = (byte *) 0 ;
11245 byte arg5 = (byte) 0 ;
11246 byte arg6 = (byte) 0 ;
11247 byte arg7 = (byte) 0 ;
11248 bool result;
11249 byte temp2 ;
11250 int res2 = 0 ;
11251 byte temp3 ;
11252 int res3 = 0 ;
11253 byte temp4 ;
11254 int res4 = 0 ;
11255 PyObject * obj0 = 0 ;
11256 PyObject * obj1 = 0 ;
11257 PyObject * obj2 = 0 ;
11258 PyObject * obj3 = 0 ;
11259 char *kwnames[] = {
11260 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11261 };
11262
11263 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11264 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11265 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11268 if (SWIG_arg_fail(1)) SWIG_fail;
11269 if (obj1) {
11270 {
11271 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11272 if (SWIG_arg_fail(5)) SWIG_fail;
11273 }
11274 }
11275 if (obj2) {
11276 {
11277 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11278 if (SWIG_arg_fail(6)) SWIG_fail;
11279 }
11280 }
11281 if (obj3) {
11282 {
11283 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11284 if (SWIG_arg_fail(7)) SWIG_fail;
11285 }
11286 }
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11290
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 {
11295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11296 }
11297 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11298 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11299 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11300 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11301 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11302 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 byte arg2 = (byte) 128 ;
11313 bool result;
11314 PyObject * obj0 = 0 ;
11315 PyObject * obj1 = 0 ;
11316 char *kwnames[] = {
11317 (char *) "self",(char *) "threshold", NULL
11318 };
11319
11320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11322 if (SWIG_arg_fail(1)) SWIG_fail;
11323 if (obj1) {
11324 {
11325 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11326 if (SWIG_arg_fail(2)) SWIG_fail;
11327 }
11328 }
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11332
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 {
11337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11338 }
11339 return resultobj;
11340 fail:
11341 return NULL;
11342 }
11343
11344
11345 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11346 PyObject *resultobj;
11347 wxImage *arg1 = (wxImage *) 0 ;
11348 unsigned char arg2 ;
11349 unsigned char arg3 ;
11350 unsigned char arg4 ;
11351 bool result;
11352 PyObject * obj0 = 0 ;
11353 PyObject * obj1 = 0 ;
11354 PyObject * obj2 = 0 ;
11355 PyObject * obj3 = 0 ;
11356 char *kwnames[] = {
11357 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11358 };
11359
11360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11362 if (SWIG_arg_fail(1)) SWIG_fail;
11363 {
11364 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11365 if (SWIG_arg_fail(2)) SWIG_fail;
11366 }
11367 {
11368 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11369 if (SWIG_arg_fail(3)) SWIG_fail;
11370 }
11371 {
11372 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11373 if (SWIG_arg_fail(4)) SWIG_fail;
11374 }
11375 {
11376 PyThreadState* __tstate = wxPyBeginAllowThreads();
11377 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11378
11379 wxPyEndAllowThreads(__tstate);
11380 if (PyErr_Occurred()) SWIG_fail;
11381 }
11382 {
11383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11384 }
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11392 PyObject *resultobj;
11393 wxImage *arg1 = (wxImage *) 0 ;
11394 wxImage *arg2 = 0 ;
11395 byte arg3 ;
11396 byte arg4 ;
11397 byte arg5 ;
11398 bool result;
11399 PyObject * obj0 = 0 ;
11400 PyObject * obj1 = 0 ;
11401 PyObject * obj2 = 0 ;
11402 PyObject * obj3 = 0 ;
11403 PyObject * obj4 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 {
11412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11413 if (SWIG_arg_fail(2)) SWIG_fail;
11414 if (arg2 == NULL) {
11415 SWIG_null_ref("wxImage");
11416 }
11417 if (SWIG_arg_fail(2)) SWIG_fail;
11418 }
11419 {
11420 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11421 if (SWIG_arg_fail(3)) SWIG_fail;
11422 }
11423 {
11424 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11425 if (SWIG_arg_fail(4)) SWIG_fail;
11426 }
11427 {
11428 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11429 if (SWIG_arg_fail(5)) SWIG_fail;
11430 }
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11434
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 {
11439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11440 }
11441 return resultobj;
11442 fail:
11443 return NULL;
11444 }
11445
11446
11447 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11448 PyObject *resultobj;
11449 wxString *arg1 = 0 ;
11450 bool result;
11451 bool temp1 = false ;
11452 PyObject * obj0 = 0 ;
11453 char *kwnames[] = {
11454 (char *) "name", NULL
11455 };
11456
11457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11458 {
11459 arg1 = wxString_in_helper(obj0);
11460 if (arg1 == NULL) SWIG_fail;
11461 temp1 = true;
11462 }
11463 {
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11466
11467 wxPyEndAllowThreads(__tstate);
11468 if (PyErr_Occurred()) SWIG_fail;
11469 }
11470 {
11471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11472 }
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return resultobj;
11478 fail:
11479 {
11480 if (temp1)
11481 delete arg1;
11482 }
11483 return NULL;
11484 }
11485
11486
11487 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj;
11489 wxString *arg1 = 0 ;
11490 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11491 int result;
11492 bool temp1 = false ;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 char *kwnames[] = {
11496 (char *) "name",(char *) "type", NULL
11497 };
11498
11499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11500 {
11501 arg1 = wxString_in_helper(obj0);
11502 if (arg1 == NULL) SWIG_fail;
11503 temp1 = true;
11504 }
11505 if (obj1) {
11506 {
11507 arg2 = (long)(SWIG_As_long(obj1));
11508 if (SWIG_arg_fail(2)) SWIG_fail;
11509 }
11510 }
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 {
11519 resultobj = SWIG_From_int((int)(result));
11520 }
11521 {
11522 if (temp1)
11523 delete arg1;
11524 }
11525 return resultobj;
11526 fail:
11527 {
11528 if (temp1)
11529 delete arg1;
11530 }
11531 return NULL;
11532 }
11533
11534
11535 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11536 PyObject *resultobj;
11537 wxImage *arg1 = (wxImage *) 0 ;
11538 wxString *arg2 = 0 ;
11539 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11540 int arg4 = (int) -1 ;
11541 bool result;
11542 bool temp2 = false ;
11543 PyObject * obj0 = 0 ;
11544 PyObject * obj1 = 0 ;
11545 PyObject * obj2 = 0 ;
11546 PyObject * obj3 = 0 ;
11547 char *kwnames[] = {
11548 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11549 };
11550
11551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11553 if (SWIG_arg_fail(1)) SWIG_fail;
11554 {
11555 arg2 = wxString_in_helper(obj1);
11556 if (arg2 == NULL) SWIG_fail;
11557 temp2 = true;
11558 }
11559 if (obj2) {
11560 {
11561 arg3 = (long)(SWIG_As_long(obj2));
11562 if (SWIG_arg_fail(3)) SWIG_fail;
11563 }
11564 }
11565 if (obj3) {
11566 {
11567 arg4 = (int)(SWIG_As_int(obj3));
11568 if (SWIG_arg_fail(4)) SWIG_fail;
11569 }
11570 }
11571 {
11572 PyThreadState* __tstate = wxPyBeginAllowThreads();
11573 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11574
11575 wxPyEndAllowThreads(__tstate);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 }
11578 {
11579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11580 }
11581 {
11582 if (temp2)
11583 delete arg2;
11584 }
11585 return resultobj;
11586 fail:
11587 {
11588 if (temp2)
11589 delete arg2;
11590 }
11591 return NULL;
11592 }
11593
11594
11595 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11596 PyObject *resultobj;
11597 wxImage *arg1 = (wxImage *) 0 ;
11598 wxString *arg2 = 0 ;
11599 wxString *arg3 = 0 ;
11600 int arg4 = (int) -1 ;
11601 bool result;
11602 bool temp2 = false ;
11603 bool temp3 = false ;
11604 PyObject * obj0 = 0 ;
11605 PyObject * obj1 = 0 ;
11606 PyObject * obj2 = 0 ;
11607 PyObject * obj3 = 0 ;
11608 char *kwnames[] = {
11609 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11610 };
11611
11612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11614 if (SWIG_arg_fail(1)) SWIG_fail;
11615 {
11616 arg2 = wxString_in_helper(obj1);
11617 if (arg2 == NULL) SWIG_fail;
11618 temp2 = true;
11619 }
11620 {
11621 arg3 = wxString_in_helper(obj2);
11622 if (arg3 == NULL) SWIG_fail;
11623 temp3 = true;
11624 }
11625 if (obj3) {
11626 {
11627 arg4 = (int)(SWIG_As_int(obj3));
11628 if (SWIG_arg_fail(4)) SWIG_fail;
11629 }
11630 }
11631 {
11632 PyThreadState* __tstate = wxPyBeginAllowThreads();
11633 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11634
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 {
11639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11640 }
11641 {
11642 if (temp2)
11643 delete arg2;
11644 }
11645 {
11646 if (temp3)
11647 delete arg3;
11648 }
11649 return resultobj;
11650 fail:
11651 {
11652 if (temp2)
11653 delete arg2;
11654 }
11655 {
11656 if (temp3)
11657 delete arg3;
11658 }
11659 return NULL;
11660 }
11661
11662
11663 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj;
11665 wxImage *arg1 = (wxImage *) 0 ;
11666 wxString *arg2 = 0 ;
11667 int arg3 ;
11668 bool result;
11669 bool temp2 = false ;
11670 PyObject * obj0 = 0 ;
11671 PyObject * obj1 = 0 ;
11672 PyObject * obj2 = 0 ;
11673 char *kwnames[] = {
11674 (char *) "self",(char *) "name",(char *) "type", NULL
11675 };
11676
11677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11679 if (SWIG_arg_fail(1)) SWIG_fail;
11680 {
11681 arg2 = wxString_in_helper(obj1);
11682 if (arg2 == NULL) SWIG_fail;
11683 temp2 = true;
11684 }
11685 {
11686 arg3 = (int)(SWIG_As_int(obj2));
11687 if (SWIG_arg_fail(3)) SWIG_fail;
11688 }
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11692
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11698 }
11699 {
11700 if (temp2)
11701 delete arg2;
11702 }
11703 return resultobj;
11704 fail:
11705 {
11706 if (temp2)
11707 delete arg2;
11708 }
11709 return NULL;
11710 }
11711
11712
11713 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11714 PyObject *resultobj;
11715 wxImage *arg1 = (wxImage *) 0 ;
11716 wxString *arg2 = 0 ;
11717 wxString *arg3 = 0 ;
11718 bool result;
11719 bool temp2 = false ;
11720 bool temp3 = false ;
11721 PyObject * obj0 = 0 ;
11722 PyObject * obj1 = 0 ;
11723 PyObject * obj2 = 0 ;
11724 char *kwnames[] = {
11725 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11726 };
11727
11728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11730 if (SWIG_arg_fail(1)) SWIG_fail;
11731 {
11732 arg2 = wxString_in_helper(obj1);
11733 if (arg2 == NULL) SWIG_fail;
11734 temp2 = true;
11735 }
11736 {
11737 arg3 = wxString_in_helper(obj2);
11738 if (arg3 == NULL) SWIG_fail;
11739 temp3 = true;
11740 }
11741 {
11742 PyThreadState* __tstate = wxPyBeginAllowThreads();
11743 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11744
11745 wxPyEndAllowThreads(__tstate);
11746 if (PyErr_Occurred()) SWIG_fail;
11747 }
11748 {
11749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11750 }
11751 {
11752 if (temp2)
11753 delete arg2;
11754 }
11755 {
11756 if (temp3)
11757 delete arg3;
11758 }
11759 return resultobj;
11760 fail:
11761 {
11762 if (temp2)
11763 delete arg2;
11764 }
11765 {
11766 if (temp3)
11767 delete arg3;
11768 }
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxInputStream *arg1 = 0 ;
11776 bool result;
11777 wxPyInputStream *temp1 ;
11778 bool created1 ;
11779 PyObject * obj0 = 0 ;
11780 char *kwnames[] = {
11781 (char *) "stream", NULL
11782 };
11783
11784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11785 {
11786 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11787 arg1 = temp1->m_wxis;
11788 created1 = false;
11789 } else {
11790 PyErr_Clear(); // clear the failure of the wxPyConvert above
11791 arg1 = wxPyCBInputStream_create(obj0, false);
11792 if (arg1 == NULL) {
11793 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11794 SWIG_fail;
11795 }
11796 created1 = true;
11797 }
11798 }
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (bool)wxImage::CanRead(*arg1);
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11808 }
11809 {
11810 if (created1)
11811 delete arg1;
11812 }
11813 return resultobj;
11814 fail:
11815 {
11816 if (created1)
11817 delete arg1;
11818 }
11819 return NULL;
11820 }
11821
11822
11823 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11824 PyObject *resultobj;
11825 wxImage *arg1 = (wxImage *) 0 ;
11826 wxInputStream *arg2 = 0 ;
11827 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11828 int arg4 = (int) -1 ;
11829 bool result;
11830 wxPyInputStream *temp2 ;
11831 bool created2 ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 PyObject * obj2 = 0 ;
11835 PyObject * obj3 = 0 ;
11836 char *kwnames[] = {
11837 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11838 };
11839
11840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11842 if (SWIG_arg_fail(1)) SWIG_fail;
11843 {
11844 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11845 arg2 = temp2->m_wxis;
11846 created2 = false;
11847 } else {
11848 PyErr_Clear(); // clear the failure of the wxPyConvert above
11849 arg2 = wxPyCBInputStream_create(obj1, false);
11850 if (arg2 == NULL) {
11851 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11852 SWIG_fail;
11853 }
11854 created2 = true;
11855 }
11856 }
11857 if (obj2) {
11858 {
11859 arg3 = (long)(SWIG_As_long(obj2));
11860 if (SWIG_arg_fail(3)) SWIG_fail;
11861 }
11862 }
11863 if (obj3) {
11864 {
11865 arg4 = (int)(SWIG_As_int(obj3));
11866 if (SWIG_arg_fail(4)) SWIG_fail;
11867 }
11868 }
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11872
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11878 }
11879 {
11880 if (created2)
11881 delete arg2;
11882 }
11883 return resultobj;
11884 fail:
11885 {
11886 if (created2)
11887 delete arg2;
11888 }
11889 return NULL;
11890 }
11891
11892
11893 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11894 PyObject *resultobj;
11895 wxImage *arg1 = (wxImage *) 0 ;
11896 wxInputStream *arg2 = 0 ;
11897 wxString *arg3 = 0 ;
11898 int arg4 = (int) -1 ;
11899 bool result;
11900 wxPyInputStream *temp2 ;
11901 bool created2 ;
11902 bool temp3 = false ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 PyObject * obj2 = 0 ;
11906 PyObject * obj3 = 0 ;
11907 char *kwnames[] = {
11908 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11909 };
11910
11911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11913 if (SWIG_arg_fail(1)) SWIG_fail;
11914 {
11915 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11916 arg2 = temp2->m_wxis;
11917 created2 = false;
11918 } else {
11919 PyErr_Clear(); // clear the failure of the wxPyConvert above
11920 arg2 = wxPyCBInputStream_create(obj1, false);
11921 if (arg2 == NULL) {
11922 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11923 SWIG_fail;
11924 }
11925 created2 = true;
11926 }
11927 }
11928 {
11929 arg3 = wxString_in_helper(obj2);
11930 if (arg3 == NULL) SWIG_fail;
11931 temp3 = true;
11932 }
11933 if (obj3) {
11934 {
11935 arg4 = (int)(SWIG_As_int(obj3));
11936 if (SWIG_arg_fail(4)) SWIG_fail;
11937 }
11938 }
11939 {
11940 PyThreadState* __tstate = wxPyBeginAllowThreads();
11941 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11942
11943 wxPyEndAllowThreads(__tstate);
11944 if (PyErr_Occurred()) SWIG_fail;
11945 }
11946 {
11947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11948 }
11949 {
11950 if (created2)
11951 delete arg2;
11952 }
11953 {
11954 if (temp3)
11955 delete arg3;
11956 }
11957 return resultobj;
11958 fail:
11959 {
11960 if (created2)
11961 delete arg2;
11962 }
11963 {
11964 if (temp3)
11965 delete arg3;
11966 }
11967 return NULL;
11968 }
11969
11970
11971 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj;
11973 wxImage *arg1 = (wxImage *) 0 ;
11974 bool result;
11975 PyObject * obj0 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (bool)(arg1)->Ok();
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11992 }
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj;
12001 wxImage *arg1 = (wxImage *) 0 ;
12002 int result;
12003 PyObject * obj0 = 0 ;
12004 char *kwnames[] = {
12005 (char *) "self", NULL
12006 };
12007
12008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12010 if (SWIG_arg_fail(1)) SWIG_fail;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (int)(arg1)->GetWidth();
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 resultobj = SWIG_From_int((int)(result));
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxImage *arg1 = (wxImage *) 0 ;
12030 int result;
12031 PyObject * obj0 = 0 ;
12032 char *kwnames[] = {
12033 (char *) "self", NULL
12034 };
12035
12036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12038 if (SWIG_arg_fail(1)) SWIG_fail;
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 result = (int)(arg1)->GetHeight();
12042
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 {
12047 resultobj = SWIG_From_int((int)(result));
12048 }
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj;
12057 wxImage *arg1 = (wxImage *) 0 ;
12058 wxSize result;
12059 PyObject * obj0 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "self", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12066 if (SWIG_arg_fail(1)) SWIG_fail;
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = wxImage_GetSize(arg1);
12070
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 {
12075 wxSize * resultptr;
12076 resultptr = new wxSize((wxSize &)(result));
12077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12078 }
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj;
12087 wxImage *arg1 = (wxImage *) 0 ;
12088 wxRect *arg2 = 0 ;
12089 SwigValueWrapper<wxImage > result;
12090 wxRect temp2 ;
12091 PyObject * obj0 = 0 ;
12092 PyObject * obj1 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self",(char *) "rect", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 arg2 = &temp2;
12102 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12103 }
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12107
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 {
12112 wxImage * resultptr;
12113 resultptr = new wxImage((wxImage &)(result));
12114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12115 }
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj;
12124 wxImage *arg1 = (wxImage *) 0 ;
12125 SwigValueWrapper<wxImage > result;
12126 PyObject * obj0 = 0 ;
12127 char *kwnames[] = {
12128 (char *) "self", NULL
12129 };
12130
12131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12133 if (SWIG_arg_fail(1)) SWIG_fail;
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (arg1)->Copy();
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 wxImage * resultptr;
12143 resultptr = new wxImage((wxImage &)(result));
12144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxImage *arg1 = (wxImage *) 0 ;
12155 wxImage *arg2 = 0 ;
12156 int arg3 ;
12157 int arg4 ;
12158 PyObject * obj0 = 0 ;
12159 PyObject * obj1 = 0 ;
12160 PyObject * obj2 = 0 ;
12161 PyObject * obj3 = 0 ;
12162 char *kwnames[] = {
12163 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12164 };
12165
12166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12168 if (SWIG_arg_fail(1)) SWIG_fail;
12169 {
12170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12171 if (SWIG_arg_fail(2)) SWIG_fail;
12172 if (arg2 == NULL) {
12173 SWIG_null_ref("wxImage");
12174 }
12175 if (SWIG_arg_fail(2)) SWIG_fail;
12176 }
12177 {
12178 arg3 = (int)(SWIG_As_int(obj2));
12179 if (SWIG_arg_fail(3)) SWIG_fail;
12180 }
12181 {
12182 arg4 = (int)(SWIG_As_int(obj3));
12183 if (SWIG_arg_fail(4)) SWIG_fail;
12184 }
12185 {
12186 PyThreadState* __tstate = wxPyBeginAllowThreads();
12187 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12188
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 Py_INCREF(Py_None); resultobj = Py_None;
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj;
12201 wxImage *arg1 = (wxImage *) 0 ;
12202 PyObject *result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (PyObject *)wxImage_GetData(arg1);
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 resultobj = result;
12219 return resultobj;
12220 fail:
12221 return NULL;
12222 }
12223
12224
12225 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12226 PyObject *resultobj;
12227 wxImage *arg1 = (wxImage *) 0 ;
12228 PyObject *arg2 = (PyObject *) 0 ;
12229 PyObject * obj0 = 0 ;
12230 PyObject * obj1 = 0 ;
12231 char *kwnames[] = {
12232 (char *) "self",(char *) "data", NULL
12233 };
12234
12235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12237 if (SWIG_arg_fail(1)) SWIG_fail;
12238 arg2 = obj1;
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 wxImage_SetData(arg1,arg2);
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 Py_INCREF(Py_None); resultobj = Py_None;
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj;
12255 wxImage *arg1 = (wxImage *) 0 ;
12256 PyObject *result;
12257 PyObject * obj0 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 resultobj = result;
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj;
12281 wxImage *arg1 = (wxImage *) 0 ;
12282 PyObject *arg2 = (PyObject *) 0 ;
12283 PyObject * obj0 = 0 ;
12284 PyObject * obj1 = 0 ;
12285 char *kwnames[] = {
12286 (char *) "self",(char *) "data", NULL
12287 };
12288
12289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12291 if (SWIG_arg_fail(1)) SWIG_fail;
12292 arg2 = obj1;
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 wxImage_SetDataBuffer(arg1,arg2);
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 Py_INCREF(Py_None); resultobj = Py_None;
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12308 PyObject *resultobj;
12309 wxImage *arg1 = (wxImage *) 0 ;
12310 PyObject *result;
12311 PyObject * obj0 = 0 ;
12312 char *kwnames[] = {
12313 (char *) "self", NULL
12314 };
12315
12316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12318 if (SWIG_arg_fail(1)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (PyObject *)wxImage_GetAlphaData(arg1);
12322
12323 wxPyEndAllowThreads(__tstate);
12324 if (PyErr_Occurred()) SWIG_fail;
12325 }
12326 resultobj = result;
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj;
12335 wxImage *arg1 = (wxImage *) 0 ;
12336 PyObject *arg2 = (PyObject *) 0 ;
12337 PyObject * obj0 = 0 ;
12338 PyObject * obj1 = 0 ;
12339 char *kwnames[] = {
12340 (char *) "self",(char *) "data", NULL
12341 };
12342
12343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12345 if (SWIG_arg_fail(1)) SWIG_fail;
12346 arg2 = obj1;
12347 {
12348 PyThreadState* __tstate = wxPyBeginAllowThreads();
12349 wxImage_SetAlphaData(arg1,arg2);
12350
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 Py_INCREF(Py_None); resultobj = Py_None;
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12362 PyObject *resultobj;
12363 wxImage *arg1 = (wxImage *) 0 ;
12364 PyObject *result;
12365 PyObject * obj0 = 0 ;
12366 char *kwnames[] = {
12367 (char *) "self", NULL
12368 };
12369
12370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12372 if (SWIG_arg_fail(1)) SWIG_fail;
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12376
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 resultobj = result;
12381 return resultobj;
12382 fail:
12383 return NULL;
12384 }
12385
12386
12387 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12388 PyObject *resultobj;
12389 wxImage *arg1 = (wxImage *) 0 ;
12390 PyObject *arg2 = (PyObject *) 0 ;
12391 PyObject * obj0 = 0 ;
12392 PyObject * obj1 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self",(char *) "data", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 arg2 = obj1;
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 wxImage_SetAlphaBuffer(arg1,arg2);
12404
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 Py_INCREF(Py_None); resultobj = Py_None;
12409 return resultobj;
12410 fail:
12411 return NULL;
12412 }
12413
12414
12415 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj;
12417 wxImage *arg1 = (wxImage *) 0 ;
12418 unsigned char arg2 ;
12419 unsigned char arg3 ;
12420 unsigned char arg4 ;
12421 PyObject * obj0 = 0 ;
12422 PyObject * obj1 = 0 ;
12423 PyObject * obj2 = 0 ;
12424 PyObject * obj3 = 0 ;
12425 char *kwnames[] = {
12426 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12427 };
12428
12429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12431 if (SWIG_arg_fail(1)) SWIG_fail;
12432 {
12433 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12434 if (SWIG_arg_fail(2)) SWIG_fail;
12435 }
12436 {
12437 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12438 if (SWIG_arg_fail(3)) SWIG_fail;
12439 }
12440 {
12441 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12442 if (SWIG_arg_fail(4)) SWIG_fail;
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 (arg1)->SetMaskColour(arg2,arg3,arg4);
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 Py_INCREF(Py_None); resultobj = Py_None;
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12459 PyObject *resultobj;
12460 wxImage *arg1 = (wxImage *) 0 ;
12461 unsigned char result;
12462 PyObject * obj0 = 0 ;
12463 char *kwnames[] = {
12464 (char *) "self", NULL
12465 };
12466
12467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12469 if (SWIG_arg_fail(1)) SWIG_fail;
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (unsigned char)(arg1)->GetMaskRed();
12473
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 {
12478 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12479 }
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12487 PyObject *resultobj;
12488 wxImage *arg1 = (wxImage *) 0 ;
12489 unsigned char result;
12490 PyObject * obj0 = 0 ;
12491 char *kwnames[] = {
12492 (char *) "self", NULL
12493 };
12494
12495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12497 if (SWIG_arg_fail(1)) SWIG_fail;
12498 {
12499 PyThreadState* __tstate = wxPyBeginAllowThreads();
12500 result = (unsigned char)(arg1)->GetMaskGreen();
12501
12502 wxPyEndAllowThreads(__tstate);
12503 if (PyErr_Occurred()) SWIG_fail;
12504 }
12505 {
12506 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12507 }
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj;
12516 wxImage *arg1 = (wxImage *) 0 ;
12517 unsigned char result;
12518 PyObject * obj0 = 0 ;
12519 char *kwnames[] = {
12520 (char *) "self", NULL
12521 };
12522
12523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12525 if (SWIG_arg_fail(1)) SWIG_fail;
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 result = (unsigned char)(arg1)->GetMaskBlue();
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 {
12534 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12535 }
12536 return resultobj;
12537 fail:
12538 return NULL;
12539 }
12540
12541
12542 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12543 PyObject *resultobj;
12544 wxImage *arg1 = (wxImage *) 0 ;
12545 bool arg2 = (bool) true ;
12546 PyObject * obj0 = 0 ;
12547 PyObject * obj1 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self",(char *) "mask", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12554 if (SWIG_arg_fail(1)) SWIG_fail;
12555 if (obj1) {
12556 {
12557 arg2 = (bool)(SWIG_As_bool(obj1));
12558 if (SWIG_arg_fail(2)) SWIG_fail;
12559 }
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 (arg1)->SetMask(arg2);
12564
12565 wxPyEndAllowThreads(__tstate);
12566 if (PyErr_Occurred()) SWIG_fail;
12567 }
12568 Py_INCREF(Py_None); resultobj = Py_None;
12569 return resultobj;
12570 fail:
12571 return NULL;
12572 }
12573
12574
12575 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12576 PyObject *resultobj;
12577 wxImage *arg1 = (wxImage *) 0 ;
12578 bool result;
12579 PyObject * obj0 = 0 ;
12580 char *kwnames[] = {
12581 (char *) "self", NULL
12582 };
12583
12584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12586 if (SWIG_arg_fail(1)) SWIG_fail;
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 result = (bool)(arg1)->HasMask();
12590
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 {
12595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12596 }
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj;
12605 wxImage *arg1 = (wxImage *) 0 ;
12606 double arg2 ;
12607 wxPoint *arg3 = 0 ;
12608 bool arg4 = (bool) true ;
12609 wxPoint *arg5 = (wxPoint *) NULL ;
12610 SwigValueWrapper<wxImage > result;
12611 wxPoint temp3 ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 PyObject * obj2 = 0 ;
12615 PyObject * obj3 = 0 ;
12616 PyObject * obj4 = 0 ;
12617 char *kwnames[] = {
12618 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12619 };
12620
12621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12623 if (SWIG_arg_fail(1)) SWIG_fail;
12624 {
12625 arg2 = (double)(SWIG_As_double(obj1));
12626 if (SWIG_arg_fail(2)) SWIG_fail;
12627 }
12628 {
12629 arg3 = &temp3;
12630 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12631 }
12632 if (obj3) {
12633 {
12634 arg4 = (bool)(SWIG_As_bool(obj3));
12635 if (SWIG_arg_fail(4)) SWIG_fail;
12636 }
12637 }
12638 if (obj4) {
12639 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12640 if (SWIG_arg_fail(5)) SWIG_fail;
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12645
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 {
12650 wxImage * resultptr;
12651 resultptr = new wxImage((wxImage &)(result));
12652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12653 }
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12661 PyObject *resultobj;
12662 wxImage *arg1 = (wxImage *) 0 ;
12663 bool arg2 = (bool) true ;
12664 SwigValueWrapper<wxImage > result;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 char *kwnames[] = {
12668 (char *) "self",(char *) "clockwise", NULL
12669 };
12670
12671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12673 if (SWIG_arg_fail(1)) SWIG_fail;
12674 if (obj1) {
12675 {
12676 arg2 = (bool)(SWIG_As_bool(obj1));
12677 if (SWIG_arg_fail(2)) SWIG_fail;
12678 }
12679 }
12680 {
12681 PyThreadState* __tstate = wxPyBeginAllowThreads();
12682 result = (arg1)->Rotate90(arg2);
12683
12684 wxPyEndAllowThreads(__tstate);
12685 if (PyErr_Occurred()) SWIG_fail;
12686 }
12687 {
12688 wxImage * resultptr;
12689 resultptr = new wxImage((wxImage &)(result));
12690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12691 }
12692 return resultobj;
12693 fail:
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj;
12700 wxImage *arg1 = (wxImage *) 0 ;
12701 bool arg2 = (bool) true ;
12702 SwigValueWrapper<wxImage > result;
12703 PyObject * obj0 = 0 ;
12704 PyObject * obj1 = 0 ;
12705 char *kwnames[] = {
12706 (char *) "self",(char *) "horizontally", NULL
12707 };
12708
12709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12711 if (SWIG_arg_fail(1)) SWIG_fail;
12712 if (obj1) {
12713 {
12714 arg2 = (bool)(SWIG_As_bool(obj1));
12715 if (SWIG_arg_fail(2)) SWIG_fail;
12716 }
12717 }
12718 {
12719 PyThreadState* __tstate = wxPyBeginAllowThreads();
12720 result = (arg1)->Mirror(arg2);
12721
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 {
12726 wxImage * resultptr;
12727 resultptr = new wxImage((wxImage &)(result));
12728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12729 }
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12737 PyObject *resultobj;
12738 wxImage *arg1 = (wxImage *) 0 ;
12739 unsigned char arg2 ;
12740 unsigned char arg3 ;
12741 unsigned char arg4 ;
12742 unsigned char arg5 ;
12743 unsigned char arg6 ;
12744 unsigned char arg7 ;
12745 PyObject * obj0 = 0 ;
12746 PyObject * obj1 = 0 ;
12747 PyObject * obj2 = 0 ;
12748 PyObject * obj3 = 0 ;
12749 PyObject * obj4 = 0 ;
12750 PyObject * obj5 = 0 ;
12751 PyObject * obj6 = 0 ;
12752 char *kwnames[] = {
12753 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12754 };
12755
12756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12758 if (SWIG_arg_fail(1)) SWIG_fail;
12759 {
12760 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12761 if (SWIG_arg_fail(2)) SWIG_fail;
12762 }
12763 {
12764 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12765 if (SWIG_arg_fail(3)) SWIG_fail;
12766 }
12767 {
12768 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12769 if (SWIG_arg_fail(4)) SWIG_fail;
12770 }
12771 {
12772 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12773 if (SWIG_arg_fail(5)) SWIG_fail;
12774 }
12775 {
12776 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12777 if (SWIG_arg_fail(6)) SWIG_fail;
12778 }
12779 {
12780 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12781 if (SWIG_arg_fail(7)) SWIG_fail;
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12786
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 Py_INCREF(Py_None); resultobj = Py_None;
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxImage *arg1 = (wxImage *) 0 ;
12800 unsigned char arg2 ;
12801 unsigned char arg3 ;
12802 unsigned char arg4 ;
12803 SwigValueWrapper<wxImage > result;
12804 PyObject * obj0 = 0 ;
12805 PyObject * obj1 = 0 ;
12806 PyObject * obj2 = 0 ;
12807 PyObject * obj3 = 0 ;
12808 char *kwnames[] = {
12809 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12810 };
12811
12812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12814 if (SWIG_arg_fail(1)) SWIG_fail;
12815 {
12816 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12817 if (SWIG_arg_fail(2)) SWIG_fail;
12818 }
12819 {
12820 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12821 if (SWIG_arg_fail(3)) SWIG_fail;
12822 }
12823 {
12824 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12825 if (SWIG_arg_fail(4)) SWIG_fail;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 {
12835 wxImage * resultptr;
12836 resultptr = new wxImage((wxImage &)(result));
12837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12838 }
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12846 PyObject *resultobj;
12847 wxImage *arg1 = (wxImage *) 0 ;
12848 wxString *arg2 = 0 ;
12849 wxString *arg3 = 0 ;
12850 bool temp2 = false ;
12851 bool temp3 = false ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 PyObject * obj2 = 0 ;
12855 char *kwnames[] = {
12856 (char *) "self",(char *) "name",(char *) "value", NULL
12857 };
12858
12859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12861 if (SWIG_arg_fail(1)) SWIG_fail;
12862 {
12863 arg2 = wxString_in_helper(obj1);
12864 if (arg2 == NULL) SWIG_fail;
12865 temp2 = true;
12866 }
12867 {
12868 arg3 = wxString_in_helper(obj2);
12869 if (arg3 == NULL) SWIG_fail;
12870 temp3 = true;
12871 }
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 Py_INCREF(Py_None); resultobj = Py_None;
12880 {
12881 if (temp2)
12882 delete arg2;
12883 }
12884 {
12885 if (temp3)
12886 delete arg3;
12887 }
12888 return resultobj;
12889 fail:
12890 {
12891 if (temp2)
12892 delete arg2;
12893 }
12894 {
12895 if (temp3)
12896 delete arg3;
12897 }
12898 return NULL;
12899 }
12900
12901
12902 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12903 PyObject *resultobj;
12904 wxImage *arg1 = (wxImage *) 0 ;
12905 wxString *arg2 = 0 ;
12906 int arg3 ;
12907 bool temp2 = false ;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12910 PyObject * obj2 = 0 ;
12911 char *kwnames[] = {
12912 (char *) "self",(char *) "name",(char *) "value", NULL
12913 };
12914
12915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12917 if (SWIG_arg_fail(1)) SWIG_fail;
12918 {
12919 arg2 = wxString_in_helper(obj1);
12920 if (arg2 == NULL) SWIG_fail;
12921 temp2 = true;
12922 }
12923 {
12924 arg3 = (int)(SWIG_As_int(obj2));
12925 if (SWIG_arg_fail(3)) SWIG_fail;
12926 }
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 (arg1)->SetOption((wxString const &)*arg2,arg3);
12930
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 Py_INCREF(Py_None); resultobj = Py_None;
12935 {
12936 if (temp2)
12937 delete arg2;
12938 }
12939 return resultobj;
12940 fail:
12941 {
12942 if (temp2)
12943 delete arg2;
12944 }
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxImage *arg1 = (wxImage *) 0 ;
12952 wxString *arg2 = 0 ;
12953 wxString result;
12954 bool temp2 = false ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char *kwnames[] = {
12958 (char *) "self",(char *) "name", NULL
12959 };
12960
12961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12963 if (SWIG_arg_fail(1)) SWIG_fail;
12964 {
12965 arg2 = wxString_in_helper(obj1);
12966 if (arg2 == NULL) SWIG_fail;
12967 temp2 = true;
12968 }
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12972
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 {
12977 #if wxUSE_UNICODE
12978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12979 #else
12980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12981 #endif
12982 }
12983 {
12984 if (temp2)
12985 delete arg2;
12986 }
12987 return resultobj;
12988 fail:
12989 {
12990 if (temp2)
12991 delete arg2;
12992 }
12993 return NULL;
12994 }
12995
12996
12997 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12998 PyObject *resultobj;
12999 wxImage *arg1 = (wxImage *) 0 ;
13000 wxString *arg2 = 0 ;
13001 int result;
13002 bool temp2 = false ;
13003 PyObject * obj0 = 0 ;
13004 PyObject * obj1 = 0 ;
13005 char *kwnames[] = {
13006 (char *) "self",(char *) "name", NULL
13007 };
13008
13009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13011 if (SWIG_arg_fail(1)) SWIG_fail;
13012 {
13013 arg2 = wxString_in_helper(obj1);
13014 if (arg2 == NULL) SWIG_fail;
13015 temp2 = true;
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 {
13025 resultobj = SWIG_From_int((int)(result));
13026 }
13027 {
13028 if (temp2)
13029 delete arg2;
13030 }
13031 return resultobj;
13032 fail:
13033 {
13034 if (temp2)
13035 delete arg2;
13036 }
13037 return NULL;
13038 }
13039
13040
13041 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13042 PyObject *resultobj;
13043 wxImage *arg1 = (wxImage *) 0 ;
13044 wxString *arg2 = 0 ;
13045 bool result;
13046 bool temp2 = false ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self",(char *) "name", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 arg2 = wxString_in_helper(obj1);
13058 if (arg2 == NULL) SWIG_fail;
13059 temp2 = true;
13060 }
13061 {
13062 PyThreadState* __tstate = wxPyBeginAllowThreads();
13063 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13064
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 {
13069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13070 }
13071 {
13072 if (temp2)
13073 delete arg2;
13074 }
13075 return resultobj;
13076 fail:
13077 {
13078 if (temp2)
13079 delete arg2;
13080 }
13081 return NULL;
13082 }
13083
13084
13085 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13086 PyObject *resultobj;
13087 wxImage *arg1 = (wxImage *) 0 ;
13088 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13089 unsigned long result;
13090 PyObject * obj0 = 0 ;
13091 PyObject * obj1 = 0 ;
13092 char *kwnames[] = {
13093 (char *) "self",(char *) "stopafter", NULL
13094 };
13095
13096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13098 if (SWIG_arg_fail(1)) SWIG_fail;
13099 if (obj1) {
13100 {
13101 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13102 if (SWIG_arg_fail(2)) SWIG_fail;
13103 }
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (unsigned long)(arg1)->CountColours(arg2);
13108
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 {
13113 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13114 }
13115 return resultobj;
13116 fail:
13117 return NULL;
13118 }
13119
13120
13121 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13122 PyObject *resultobj;
13123 wxImage *arg1 = (wxImage *) 0 ;
13124 wxImageHistogram *arg2 = 0 ;
13125 unsigned long result;
13126 PyObject * obj0 = 0 ;
13127 PyObject * obj1 = 0 ;
13128 char *kwnames[] = {
13129 (char *) "self",(char *) "h", NULL
13130 };
13131
13132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13134 if (SWIG_arg_fail(1)) SWIG_fail;
13135 {
13136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(2)) SWIG_fail;
13138 if (arg2 == NULL) {
13139 SWIG_null_ref("wxImageHistogram");
13140 }
13141 if (SWIG_arg_fail(2)) SWIG_fail;
13142 }
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 {
13151 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13152 }
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13162 PyObject * obj0 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "handler", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 wxImage::AddHandler(arg1);
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 Py_INCREF(Py_None); resultobj = Py_None;
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj;
13186 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13187 PyObject * obj0 = 0 ;
13188 char *kwnames[] = {
13189 (char *) "handler", NULL
13190 };
13191
13192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13194 if (SWIG_arg_fail(1)) SWIG_fail;
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 wxImage::InsertHandler(arg1);
13198
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 Py_INCREF(Py_None); resultobj = Py_None;
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj;
13211 wxString *arg1 = 0 ;
13212 bool result;
13213 bool temp1 = false ;
13214 PyObject * obj0 = 0 ;
13215 char *kwnames[] = {
13216 (char *) "name", NULL
13217 };
13218
13219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13220 {
13221 arg1 = wxString_in_helper(obj0);
13222 if (arg1 == NULL) SWIG_fail;
13223 temp1 = true;
13224 }
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 {
13233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13234 }
13235 {
13236 if (temp1)
13237 delete arg1;
13238 }
13239 return resultobj;
13240 fail:
13241 {
13242 if (temp1)
13243 delete arg1;
13244 }
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxString result;
13252 char *kwnames[] = {
13253 NULL
13254 };
13255
13256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 result = wxImage::GetImageExtWildcard();
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 {
13265 #if wxUSE_UNICODE
13266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13267 #else
13268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13269 #endif
13270 }
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj;
13279 wxImage *arg1 = (wxImage *) 0 ;
13280 int arg2 = (int) -1 ;
13281 wxBitmap result;
13282 PyObject * obj0 = 0 ;
13283 PyObject * obj1 = 0 ;
13284 char *kwnames[] = {
13285 (char *) "self",(char *) "depth", NULL
13286 };
13287
13288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13290 if (SWIG_arg_fail(1)) SWIG_fail;
13291 if (obj1) {
13292 {
13293 arg2 = (int)(SWIG_As_int(obj1));
13294 if (SWIG_arg_fail(2)) SWIG_fail;
13295 }
13296 }
13297 {
13298 if (!wxPyCheckForApp()) SWIG_fail;
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = wxImage_ConvertToBitmap(arg1,arg2);
13301
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 {
13306 wxBitmap * resultptr;
13307 resultptr = new wxBitmap((wxBitmap &)(result));
13308 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13309 }
13310 return resultobj;
13311 fail:
13312 return NULL;
13313 }
13314
13315
13316 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13317 PyObject *resultobj;
13318 wxImage *arg1 = (wxImage *) 0 ;
13319 unsigned char arg2 ;
13320 unsigned char arg3 ;
13321 unsigned char arg4 ;
13322 wxBitmap result;
13323 PyObject * obj0 = 0 ;
13324 PyObject * obj1 = 0 ;
13325 PyObject * obj2 = 0 ;
13326 PyObject * obj3 = 0 ;
13327 char *kwnames[] = {
13328 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13329 };
13330
13331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13333 if (SWIG_arg_fail(1)) SWIG_fail;
13334 {
13335 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13336 if (SWIG_arg_fail(2)) SWIG_fail;
13337 }
13338 {
13339 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13340 if (SWIG_arg_fail(3)) SWIG_fail;
13341 }
13342 {
13343 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13344 if (SWIG_arg_fail(4)) SWIG_fail;
13345 }
13346 {
13347 if (!wxPyCheckForApp()) SWIG_fail;
13348 PyThreadState* __tstate = wxPyBeginAllowThreads();
13349 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13350
13351 wxPyEndAllowThreads(__tstate);
13352 if (PyErr_Occurred()) SWIG_fail;
13353 }
13354 {
13355 wxBitmap * resultptr;
13356 resultptr = new wxBitmap((wxBitmap &)(result));
13357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13358 }
13359 return resultobj;
13360 fail:
13361 return NULL;
13362 }
13363
13364
13365 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13366 PyObject *obj;
13367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13368 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13369 Py_INCREF(obj);
13370 return Py_BuildValue((char *)"");
13371 }
13372 static int _wrap_NullImage_set(PyObject *) {
13373 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13374 return 1;
13375 }
13376
13377
13378 static PyObject *_wrap_NullImage_get(void) {
13379 PyObject *pyobj;
13380
13381 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13382 return pyobj;
13383 }
13384
13385
13386 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13387 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13388 return 1;
13389 }
13390
13391
13392 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13393 PyObject *pyobj;
13394
13395 {
13396 #if wxUSE_UNICODE
13397 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13398 #else
13399 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13400 #endif
13401 }
13402 return pyobj;
13403 }
13404
13405
13406 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13407 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13408 return 1;
13409 }
13410
13411
13412 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13413 PyObject *pyobj;
13414
13415 {
13416 #if wxUSE_UNICODE
13417 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13418 #else
13419 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13420 #endif
13421 }
13422 return pyobj;
13423 }
13424
13425
13426 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13427 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13428 return 1;
13429 }
13430
13431
13432 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13433 PyObject *pyobj;
13434
13435 {
13436 #if wxUSE_UNICODE
13437 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13438 #else
13439 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13440 #endif
13441 }
13442 return pyobj;
13443 }
13444
13445
13446 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13447 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13448 return 1;
13449 }
13450
13451
13452 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13453 PyObject *pyobj;
13454
13455 {
13456 #if wxUSE_UNICODE
13457 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13458 #else
13459 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13460 #endif
13461 }
13462 return pyobj;
13463 }
13464
13465
13466 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13467 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13468 return 1;
13469 }
13470
13471
13472 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13473 PyObject *pyobj;
13474
13475 {
13476 #if wxUSE_UNICODE
13477 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13478 #else
13479 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13480 #endif
13481 }
13482 return pyobj;
13483 }
13484
13485
13486 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13487 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13488 return 1;
13489 }
13490
13491
13492 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13493 PyObject *pyobj;
13494
13495 {
13496 #if wxUSE_UNICODE
13497 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13498 #else
13499 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13500 #endif
13501 }
13502 return pyobj;
13503 }
13504
13505
13506 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13507 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13508 return 1;
13509 }
13510
13511
13512 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13513 PyObject *pyobj;
13514
13515 {
13516 #if wxUSE_UNICODE
13517 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13518 #else
13519 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13520 #endif
13521 }
13522 return pyobj;
13523 }
13524
13525
13526 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13527 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13528 return 1;
13529 }
13530
13531
13532 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13533 PyObject *pyobj;
13534
13535 {
13536 #if wxUSE_UNICODE
13537 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13538 #else
13539 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13540 #endif
13541 }
13542 return pyobj;
13543 }
13544
13545
13546 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13547 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13548 return 1;
13549 }
13550
13551
13552 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13553 PyObject *pyobj;
13554
13555 {
13556 #if wxUSE_UNICODE
13557 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13558 #else
13559 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13560 #endif
13561 }
13562 return pyobj;
13563 }
13564
13565
13566 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13567 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13568 return 1;
13569 }
13570
13571
13572 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13573 PyObject *pyobj;
13574
13575 {
13576 #if wxUSE_UNICODE
13577 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13578 #else
13579 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13580 #endif
13581 }
13582 return pyobj;
13583 }
13584
13585
13586 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13587 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13588 return 1;
13589 }
13590
13591
13592 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13593 PyObject *pyobj;
13594
13595 {
13596 #if wxUSE_UNICODE
13597 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13598 #else
13599 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13600 #endif
13601 }
13602 return pyobj;
13603 }
13604
13605
13606 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13607 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13608 return 1;
13609 }
13610
13611
13612 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13613 PyObject *pyobj;
13614
13615 {
13616 #if wxUSE_UNICODE
13617 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13618 #else
13619 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13620 #endif
13621 }
13622 return pyobj;
13623 }
13624
13625
13626 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13627 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13628 return 1;
13629 }
13630
13631
13632 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13633 PyObject *pyobj;
13634
13635 {
13636 #if wxUSE_UNICODE
13637 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13638 #else
13639 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13640 #endif
13641 }
13642 return pyobj;
13643 }
13644
13645
13646 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13647 PyObject *resultobj;
13648 wxBMPHandler *result;
13649 char *kwnames[] = {
13650 NULL
13651 };
13652
13653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 result = (wxBMPHandler *)new wxBMPHandler();
13657
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13662 return resultobj;
13663 fail:
13664 return NULL;
13665 }
13666
13667
13668 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13669 PyObject *obj;
13670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13671 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13672 Py_INCREF(obj);
13673 return Py_BuildValue((char *)"");
13674 }
13675 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13676 PyObject *resultobj;
13677 wxICOHandler *result;
13678 char *kwnames[] = {
13679 NULL
13680 };
13681
13682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = (wxICOHandler *)new wxICOHandler();
13686
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13698 PyObject *obj;
13699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13700 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13701 Py_INCREF(obj);
13702 return Py_BuildValue((char *)"");
13703 }
13704 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj;
13706 wxCURHandler *result;
13707 char *kwnames[] = {
13708 NULL
13709 };
13710
13711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 result = (wxCURHandler *)new wxCURHandler();
13715
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13720 return resultobj;
13721 fail:
13722 return NULL;
13723 }
13724
13725
13726 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13727 PyObject *obj;
13728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13729 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13730 Py_INCREF(obj);
13731 return Py_BuildValue((char *)"");
13732 }
13733 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxANIHandler *result;
13736 char *kwnames[] = {
13737 NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (wxANIHandler *)new wxANIHandler();
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13756 PyObject *obj;
13757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13758 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13759 Py_INCREF(obj);
13760 return Py_BuildValue((char *)"");
13761 }
13762 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxPNGHandler *result;
13765 char *kwnames[] = {
13766 NULL
13767 };
13768
13769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 result = (wxPNGHandler *)new wxPNGHandler();
13773
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13778 return resultobj;
13779 fail:
13780 return NULL;
13781 }
13782
13783
13784 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13785 PyObject *obj;
13786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13787 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13788 Py_INCREF(obj);
13789 return Py_BuildValue((char *)"");
13790 }
13791 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13792 PyObject *resultobj;
13793 wxGIFHandler *result;
13794 char *kwnames[] = {
13795 NULL
13796 };
13797
13798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = (wxGIFHandler *)new wxGIFHandler();
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13814 PyObject *obj;
13815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13816 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13817 Py_INCREF(obj);
13818 return Py_BuildValue((char *)"");
13819 }
13820 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj;
13822 wxPCXHandler *result;
13823 char *kwnames[] = {
13824 NULL
13825 };
13826
13827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 result = (wxPCXHandler *)new wxPCXHandler();
13831
13832 wxPyEndAllowThreads(__tstate);
13833 if (PyErr_Occurred()) SWIG_fail;
13834 }
13835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13836 return resultobj;
13837 fail:
13838 return NULL;
13839 }
13840
13841
13842 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13843 PyObject *obj;
13844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13845 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13846 Py_INCREF(obj);
13847 return Py_BuildValue((char *)"");
13848 }
13849 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxJPEGHandler *result;
13852 char *kwnames[] = {
13853 NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (wxJPEGHandler *)new wxJPEGHandler();
13860
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13872 PyObject *obj;
13873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13874 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13875 Py_INCREF(obj);
13876 return Py_BuildValue((char *)"");
13877 }
13878 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxPNMHandler *result;
13881 char *kwnames[] = {
13882 NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 result = (wxPNMHandler *)new wxPNMHandler();
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13901 PyObject *obj;
13902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13903 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13904 Py_INCREF(obj);
13905 return Py_BuildValue((char *)"");
13906 }
13907 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13908 PyObject *resultobj;
13909 wxXPMHandler *result;
13910 char *kwnames[] = {
13911 NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 result = (wxXPMHandler *)new wxXPMHandler();
13918
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13923 return resultobj;
13924 fail:
13925 return NULL;
13926 }
13927
13928
13929 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13930 PyObject *obj;
13931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13932 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13933 Py_INCREF(obj);
13934 return Py_BuildValue((char *)"");
13935 }
13936 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13937 PyObject *resultobj;
13938 wxTIFFHandler *result;
13939 char *kwnames[] = {
13940 NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = (wxTIFFHandler *)new wxTIFFHandler();
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13959 PyObject *obj;
13960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13961 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13962 Py_INCREF(obj);
13963 return Py_BuildValue((char *)"");
13964 }
13965 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxImage *arg1 = 0 ;
13968 wxImage *arg2 = 0 ;
13969 int arg3 = (int) 236 ;
13970 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13971 bool result;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 PyObject * obj3 = 0 ;
13976 char *kwnames[] = {
13977 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13978 };
13979
13980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13981 {
13982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13983 if (SWIG_arg_fail(1)) SWIG_fail;
13984 if (arg1 == NULL) {
13985 SWIG_null_ref("wxImage");
13986 }
13987 if (SWIG_arg_fail(1)) SWIG_fail;
13988 }
13989 {
13990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13991 if (SWIG_arg_fail(2)) SWIG_fail;
13992 if (arg2 == NULL) {
13993 SWIG_null_ref("wxImage");
13994 }
13995 if (SWIG_arg_fail(2)) SWIG_fail;
13996 }
13997 if (obj2) {
13998 {
13999 arg3 = (int)(SWIG_As_int(obj2));
14000 if (SWIG_arg_fail(3)) SWIG_fail;
14001 }
14002 }
14003 if (obj3) {
14004 {
14005 arg4 = (int)(SWIG_As_int(obj3));
14006 if (SWIG_arg_fail(4)) SWIG_fail;
14007 }
14008 }
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14012
14013 wxPyEndAllowThreads(__tstate);
14014 if (PyErr_Occurred()) SWIG_fail;
14015 }
14016 {
14017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14018 }
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14026 PyObject *obj;
14027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14028 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14029 Py_INCREF(obj);
14030 return Py_BuildValue((char *)"");
14031 }
14032 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj;
14034 wxEvtHandler *result;
14035 char *kwnames[] = {
14036 NULL
14037 };
14038
14039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = (wxEvtHandler *)new wxEvtHandler();
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14055 PyObject *resultobj;
14056 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14057 wxEvtHandler *result;
14058 PyObject * obj0 = 0 ;
14059 char *kwnames[] = {
14060 (char *) "self", NULL
14061 };
14062
14063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14065 if (SWIG_arg_fail(1)) SWIG_fail;
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14069
14070 wxPyEndAllowThreads(__tstate);
14071 if (PyErr_Occurred()) SWIG_fail;
14072 }
14073 {
14074 resultobj = wxPyMake_wxObject(result, 0);
14075 }
14076 return resultobj;
14077 fail:
14078 return NULL;
14079 }
14080
14081
14082 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj;
14084 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14085 wxEvtHandler *result;
14086 PyObject * obj0 = 0 ;
14087 char *kwnames[] = {
14088 (char *) "self", NULL
14089 };
14090
14091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(1)) SWIG_fail;
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14097
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 {
14102 resultobj = wxPyMake_wxObject(result, 0);
14103 }
14104 return resultobj;
14105 fail:
14106 return NULL;
14107 }
14108
14109
14110 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj;
14112 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14113 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14114 PyObject * obj0 = 0 ;
14115 PyObject * obj1 = 0 ;
14116 char *kwnames[] = {
14117 (char *) "self",(char *) "handler", NULL
14118 };
14119
14120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14122 if (SWIG_arg_fail(1)) SWIG_fail;
14123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14124 if (SWIG_arg_fail(2)) SWIG_fail;
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 (arg1)->SetNextHandler(arg2);
14128
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 Py_INCREF(Py_None); resultobj = Py_None;
14133 return resultobj;
14134 fail:
14135 return NULL;
14136 }
14137
14138
14139 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14140 PyObject *resultobj;
14141 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14142 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14143 PyObject * obj0 = 0 ;
14144 PyObject * obj1 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self",(char *) "handler", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(2)) SWIG_fail;
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 (arg1)->SetPreviousHandler(arg2);
14157
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 Py_INCREF(Py_None); resultobj = Py_None;
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14169 PyObject *resultobj;
14170 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14171 bool result;
14172 PyObject * obj0 = 0 ;
14173 char *kwnames[] = {
14174 (char *) "self", NULL
14175 };
14176
14177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14179 if (SWIG_arg_fail(1)) SWIG_fail;
14180 {
14181 PyThreadState* __tstate = wxPyBeginAllowThreads();
14182 result = (bool)(arg1)->GetEvtHandlerEnabled();
14183
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 {
14188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14189 }
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14199 bool arg2 ;
14200 PyObject * obj0 = 0 ;
14201 PyObject * obj1 = 0 ;
14202 char *kwnames[] = {
14203 (char *) "self",(char *) "enabled", NULL
14204 };
14205
14206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14208 if (SWIG_arg_fail(1)) SWIG_fail;
14209 {
14210 arg2 = (bool)(SWIG_As_bool(obj1));
14211 if (SWIG_arg_fail(2)) SWIG_fail;
14212 }
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 (arg1)->SetEvtHandlerEnabled(arg2);
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 Py_INCREF(Py_None); resultobj = Py_None;
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj;
14229 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14230 wxEvent *arg2 = 0 ;
14231 bool result;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 char *kwnames[] = {
14235 (char *) "self",(char *) "event", NULL
14236 };
14237
14238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14240 if (SWIG_arg_fail(1)) SWIG_fail;
14241 {
14242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(2)) SWIG_fail;
14244 if (arg2 == NULL) {
14245 SWIG_null_ref("wxEvent");
14246 }
14247 if (SWIG_arg_fail(2)) SWIG_fail;
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 result = (bool)(arg1)->ProcessEvent(*arg2);
14252
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 {
14257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14258 }
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14266 PyObject *resultobj;
14267 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14268 wxEvent *arg2 = 0 ;
14269 PyObject * obj0 = 0 ;
14270 PyObject * obj1 = 0 ;
14271 char *kwnames[] = {
14272 (char *) "self",(char *) "event", NULL
14273 };
14274
14275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14277 if (SWIG_arg_fail(1)) SWIG_fail;
14278 {
14279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14280 if (SWIG_arg_fail(2)) SWIG_fail;
14281 if (arg2 == NULL) {
14282 SWIG_null_ref("wxEvent");
14283 }
14284 if (SWIG_arg_fail(2)) SWIG_fail;
14285 }
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 (arg1)->AddPendingEvent(*arg2);
14289
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 Py_INCREF(Py_None); resultobj = Py_None;
14294 return resultobj;
14295 fail:
14296 return NULL;
14297 }
14298
14299
14300 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14303 PyObject * obj0 = 0 ;
14304 char *kwnames[] = {
14305 (char *) "self", NULL
14306 };
14307
14308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14310 if (SWIG_arg_fail(1)) SWIG_fail;
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 (arg1)->ProcessPendingEvents();
14314
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 Py_INCREF(Py_None); resultobj = Py_None;
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj;
14327 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14328 int arg2 ;
14329 int arg3 ;
14330 int arg4 ;
14331 PyObject *arg5 = (PyObject *) 0 ;
14332 PyObject * obj0 = 0 ;
14333 PyObject * obj1 = 0 ;
14334 PyObject * obj2 = 0 ;
14335 PyObject * obj3 = 0 ;
14336 PyObject * obj4 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 arg2 = (int)(SWIG_As_int(obj1));
14346 if (SWIG_arg_fail(2)) SWIG_fail;
14347 }
14348 {
14349 arg3 = (int)(SWIG_As_int(obj2));
14350 if (SWIG_arg_fail(3)) SWIG_fail;
14351 }
14352 {
14353 arg4 = (int)(SWIG_As_int(obj3));
14354 if (SWIG_arg_fail(4)) SWIG_fail;
14355 }
14356 arg5 = obj4;
14357 {
14358 PyThreadState* __tstate = wxPyBeginAllowThreads();
14359 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14360
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 Py_INCREF(Py_None); resultobj = Py_None;
14365 return resultobj;
14366 fail:
14367 return NULL;
14368 }
14369
14370
14371 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14372 PyObject *resultobj;
14373 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14374 int arg2 ;
14375 int arg3 = (int) -1 ;
14376 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14377 bool result;
14378 PyObject * obj0 = 0 ;
14379 PyObject * obj1 = 0 ;
14380 PyObject * obj2 = 0 ;
14381 PyObject * obj3 = 0 ;
14382 char *kwnames[] = {
14383 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14384 };
14385
14386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14388 if (SWIG_arg_fail(1)) SWIG_fail;
14389 {
14390 arg2 = (int)(SWIG_As_int(obj1));
14391 if (SWIG_arg_fail(2)) SWIG_fail;
14392 }
14393 if (obj2) {
14394 {
14395 arg3 = (int)(SWIG_As_int(obj2));
14396 if (SWIG_arg_fail(3)) SWIG_fail;
14397 }
14398 }
14399 if (obj3) {
14400 {
14401 arg4 = (wxEventType)(SWIG_As_int(obj3));
14402 if (SWIG_arg_fail(4)) SWIG_fail;
14403 }
14404 }
14405 {
14406 PyThreadState* __tstate = wxPyBeginAllowThreads();
14407 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14408
14409 wxPyEndAllowThreads(__tstate);
14410 if (PyErr_Occurred()) SWIG_fail;
14411 }
14412 {
14413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14414 }
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj;
14423 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14424 PyObject *arg2 = (PyObject *) 0 ;
14425 bool arg3 = (bool) true ;
14426 PyObject * obj0 = 0 ;
14427 PyObject * obj1 = 0 ;
14428 PyObject * obj2 = 0 ;
14429 char *kwnames[] = {
14430 (char *) "self",(char *) "_self",(char *) "incref", NULL
14431 };
14432
14433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14435 if (SWIG_arg_fail(1)) SWIG_fail;
14436 arg2 = obj1;
14437 if (obj2) {
14438 {
14439 arg3 = (bool)(SWIG_As_bool(obj2));
14440 if (SWIG_arg_fail(3)) SWIG_fail;
14441 }
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14446
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 Py_INCREF(Py_None); resultobj = Py_None;
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14458 PyObject *obj;
14459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14460 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14461 Py_INCREF(obj);
14462 return Py_BuildValue((char *)"");
14463 }
14464 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14465 PyObject *resultobj;
14466 wxEventType result;
14467 char *kwnames[] = {
14468 NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14472 {
14473 PyThreadState* __tstate = wxPyBeginAllowThreads();
14474 result = (wxEventType)wxNewEventType();
14475
14476 wxPyEndAllowThreads(__tstate);
14477 if (PyErr_Occurred()) SWIG_fail;
14478 }
14479 {
14480 resultobj = SWIG_From_int((int)(result));
14481 }
14482 return resultobj;
14483 fail:
14484 return NULL;
14485 }
14486
14487
14488 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14489 PyObject *resultobj;
14490 wxEvent *arg1 = (wxEvent *) 0 ;
14491 PyObject * obj0 = 0 ;
14492 char *kwnames[] = {
14493 (char *) "self", NULL
14494 };
14495
14496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14498 if (SWIG_arg_fail(1)) SWIG_fail;
14499 {
14500 PyThreadState* __tstate = wxPyBeginAllowThreads();
14501 delete arg1;
14502
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 Py_INCREF(Py_None); resultobj = Py_None;
14507 return resultobj;
14508 fail:
14509 return NULL;
14510 }
14511
14512
14513 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14514 PyObject *resultobj;
14515 wxEvent *arg1 = (wxEvent *) 0 ;
14516 wxEventType arg2 ;
14517 PyObject * obj0 = 0 ;
14518 PyObject * obj1 = 0 ;
14519 char *kwnames[] = {
14520 (char *) "self",(char *) "typ", NULL
14521 };
14522
14523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14525 if (SWIG_arg_fail(1)) SWIG_fail;
14526 {
14527 arg2 = (wxEventType)(SWIG_As_int(obj1));
14528 if (SWIG_arg_fail(2)) SWIG_fail;
14529 }
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 (arg1)->SetEventType(arg2);
14533
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 Py_INCREF(Py_None); resultobj = Py_None;
14538 return resultobj;
14539 fail:
14540 return NULL;
14541 }
14542
14543
14544 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14545 PyObject *resultobj;
14546 wxEvent *arg1 = (wxEvent *) 0 ;
14547 wxEventType result;
14548 PyObject * obj0 = 0 ;
14549 char *kwnames[] = {
14550 (char *) "self", NULL
14551 };
14552
14553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14555 if (SWIG_arg_fail(1)) SWIG_fail;
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14559
14560 wxPyEndAllowThreads(__tstate);
14561 if (PyErr_Occurred()) SWIG_fail;
14562 }
14563 {
14564 resultobj = SWIG_From_int((int)(result));
14565 }
14566 return resultobj;
14567 fail:
14568 return NULL;
14569 }
14570
14571
14572 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj;
14574 wxEvent *arg1 = (wxEvent *) 0 ;
14575 wxObject *result;
14576 PyObject * obj0 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14587
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 {
14592 resultobj = wxPyMake_wxObject(result, 0);
14593 }
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14601 PyObject *resultobj;
14602 wxEvent *arg1 = (wxEvent *) 0 ;
14603 wxObject *arg2 = (wxObject *) 0 ;
14604 PyObject * obj0 = 0 ;
14605 PyObject * obj1 = 0 ;
14606 char *kwnames[] = {
14607 (char *) "self",(char *) "obj", NULL
14608 };
14609
14610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14612 if (SWIG_arg_fail(1)) SWIG_fail;
14613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14614 if (SWIG_arg_fail(2)) SWIG_fail;
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 (arg1)->SetEventObject(arg2);
14618
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 Py_INCREF(Py_None); resultobj = Py_None;
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14630 PyObject *resultobj;
14631 wxEvent *arg1 = (wxEvent *) 0 ;
14632 long result;
14633 PyObject * obj0 = 0 ;
14634 char *kwnames[] = {
14635 (char *) "self", NULL
14636 };
14637
14638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14640 if (SWIG_arg_fail(1)) SWIG_fail;
14641 {
14642 PyThreadState* __tstate = wxPyBeginAllowThreads();
14643 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14644
14645 wxPyEndAllowThreads(__tstate);
14646 if (PyErr_Occurred()) SWIG_fail;
14647 }
14648 {
14649 resultobj = SWIG_From_long((long)(result));
14650 }
14651 return resultobj;
14652 fail:
14653 return NULL;
14654 }
14655
14656
14657 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14658 PyObject *resultobj;
14659 wxEvent *arg1 = (wxEvent *) 0 ;
14660 long arg2 = (long) 0 ;
14661 PyObject * obj0 = 0 ;
14662 PyObject * obj1 = 0 ;
14663 char *kwnames[] = {
14664 (char *) "self",(char *) "ts", NULL
14665 };
14666
14667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14669 if (SWIG_arg_fail(1)) SWIG_fail;
14670 if (obj1) {
14671 {
14672 arg2 = (long)(SWIG_As_long(obj1));
14673 if (SWIG_arg_fail(2)) SWIG_fail;
14674 }
14675 }
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 (arg1)->SetTimestamp(arg2);
14679
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 Py_INCREF(Py_None); resultobj = Py_None;
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj;
14692 wxEvent *arg1 = (wxEvent *) 0 ;
14693 int result;
14694 PyObject * obj0 = 0 ;
14695 char *kwnames[] = {
14696 (char *) "self", NULL
14697 };
14698
14699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14701 if (SWIG_arg_fail(1)) SWIG_fail;
14702 {
14703 PyThreadState* __tstate = wxPyBeginAllowThreads();
14704 result = (int)((wxEvent const *)arg1)->GetId();
14705
14706 wxPyEndAllowThreads(__tstate);
14707 if (PyErr_Occurred()) SWIG_fail;
14708 }
14709 {
14710 resultobj = SWIG_From_int((int)(result));
14711 }
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj;
14720 wxEvent *arg1 = (wxEvent *) 0 ;
14721 int arg2 ;
14722 PyObject * obj0 = 0 ;
14723 PyObject * obj1 = 0 ;
14724 char *kwnames[] = {
14725 (char *) "self",(char *) "Id", NULL
14726 };
14727
14728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14730 if (SWIG_arg_fail(1)) SWIG_fail;
14731 {
14732 arg2 = (int)(SWIG_As_int(obj1));
14733 if (SWIG_arg_fail(2)) SWIG_fail;
14734 }
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 (arg1)->SetId(arg2);
14738
14739 wxPyEndAllowThreads(__tstate);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 }
14742 Py_INCREF(Py_None); resultobj = Py_None;
14743 return resultobj;
14744 fail:
14745 return NULL;
14746 }
14747
14748
14749 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj;
14751 wxEvent *arg1 = (wxEvent *) 0 ;
14752 bool result;
14753 PyObject * obj0 = 0 ;
14754 char *kwnames[] = {
14755 (char *) "self", NULL
14756 };
14757
14758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14760 if (SWIG_arg_fail(1)) SWIG_fail;
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14764
14765 wxPyEndAllowThreads(__tstate);
14766 if (PyErr_Occurred()) SWIG_fail;
14767 }
14768 {
14769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14770 }
14771 return resultobj;
14772 fail:
14773 return NULL;
14774 }
14775
14776
14777 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14778 PyObject *resultobj;
14779 wxEvent *arg1 = (wxEvent *) 0 ;
14780 bool arg2 = (bool) true ;
14781 PyObject * obj0 = 0 ;
14782 PyObject * obj1 = 0 ;
14783 char *kwnames[] = {
14784 (char *) "self",(char *) "skip", NULL
14785 };
14786
14787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14789 if (SWIG_arg_fail(1)) SWIG_fail;
14790 if (obj1) {
14791 {
14792 arg2 = (bool)(SWIG_As_bool(obj1));
14793 if (SWIG_arg_fail(2)) SWIG_fail;
14794 }
14795 }
14796 {
14797 PyThreadState* __tstate = wxPyBeginAllowThreads();
14798 (arg1)->Skip(arg2);
14799
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 Py_INCREF(Py_None); resultobj = Py_None;
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14811 PyObject *resultobj;
14812 wxEvent *arg1 = (wxEvent *) 0 ;
14813 bool result;
14814 PyObject * obj0 = 0 ;
14815 char *kwnames[] = {
14816 (char *) "self", NULL
14817 };
14818
14819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14821 if (SWIG_arg_fail(1)) SWIG_fail;
14822 {
14823 PyThreadState* __tstate = wxPyBeginAllowThreads();
14824 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14825
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 {
14830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14831 }
14832 return resultobj;
14833 fail:
14834 return NULL;
14835 }
14836
14837
14838 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14839 PyObject *resultobj;
14840 wxEvent *arg1 = (wxEvent *) 0 ;
14841 bool result;
14842 PyObject * obj0 = 0 ;
14843 char *kwnames[] = {
14844 (char *) "self", NULL
14845 };
14846
14847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14849 if (SWIG_arg_fail(1)) SWIG_fail;
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14853
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj;
14868 wxEvent *arg1 = (wxEvent *) 0 ;
14869 int result;
14870 PyObject * obj0 = 0 ;
14871 char *kwnames[] = {
14872 (char *) "self", NULL
14873 };
14874
14875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14877 if (SWIG_arg_fail(1)) SWIG_fail;
14878 {
14879 PyThreadState* __tstate = wxPyBeginAllowThreads();
14880 result = (int)(arg1)->StopPropagation();
14881
14882 wxPyEndAllowThreads(__tstate);
14883 if (PyErr_Occurred()) SWIG_fail;
14884 }
14885 {
14886 resultobj = SWIG_From_int((int)(result));
14887 }
14888 return resultobj;
14889 fail:
14890 return NULL;
14891 }
14892
14893
14894 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxEvent *arg1 = (wxEvent *) 0 ;
14897 int arg2 ;
14898 PyObject * obj0 = 0 ;
14899 PyObject * obj1 = 0 ;
14900 char *kwnames[] = {
14901 (char *) "self",(char *) "propagationLevel", NULL
14902 };
14903
14904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14906 if (SWIG_arg_fail(1)) SWIG_fail;
14907 {
14908 arg2 = (int)(SWIG_As_int(obj1));
14909 if (SWIG_arg_fail(2)) SWIG_fail;
14910 }
14911 {
14912 PyThreadState* __tstate = wxPyBeginAllowThreads();
14913 (arg1)->ResumePropagation(arg2);
14914
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 Py_INCREF(Py_None); resultobj = Py_None;
14919 return resultobj;
14920 fail:
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxEvent *arg1 = (wxEvent *) 0 ;
14928 wxEvent *result;
14929 PyObject * obj0 = 0 ;
14930 char *kwnames[] = {
14931 (char *) "self", NULL
14932 };
14933
14934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14936 if (SWIG_arg_fail(1)) SWIG_fail;
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 result = (wxEvent *)(arg1)->Clone();
14940
14941 wxPyEndAllowThreads(__tstate);
14942 if (PyErr_Occurred()) SWIG_fail;
14943 }
14944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14945 return resultobj;
14946 fail:
14947 return NULL;
14948 }
14949
14950
14951 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14952 PyObject *obj;
14953 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14954 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14955 Py_INCREF(obj);
14956 return Py_BuildValue((char *)"");
14957 }
14958 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj;
14960 wxEvent *arg1 = 0 ;
14961 wxPropagationDisabler *result;
14962 PyObject * obj0 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "event", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14968 {
14969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14970 if (SWIG_arg_fail(1)) SWIG_fail;
14971 if (arg1 == NULL) {
14972 SWIG_null_ref("wxEvent");
14973 }
14974 if (SWIG_arg_fail(1)) SWIG_fail;
14975 }
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14979
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14991 PyObject *resultobj;
14992 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14993 PyObject * obj0 = 0 ;
14994 char *kwnames[] = {
14995 (char *) "self", NULL
14996 };
14997
14998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15000 if (SWIG_arg_fail(1)) SWIG_fail;
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 delete arg1;
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 Py_INCREF(Py_None); resultobj = Py_None;
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15016 PyObject *obj;
15017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15018 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15019 Py_INCREF(obj);
15020 return Py_BuildValue((char *)"");
15021 }
15022 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxEvent *arg1 = 0 ;
15025 wxPropagateOnce *result;
15026 PyObject * obj0 = 0 ;
15027 char *kwnames[] = {
15028 (char *) "event", NULL
15029 };
15030
15031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15032 {
15033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15034 if (SWIG_arg_fail(1)) SWIG_fail;
15035 if (arg1 == NULL) {
15036 SWIG_null_ref("wxEvent");
15037 }
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 }
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15043
15044 wxPyEndAllowThreads(__tstate);
15045 if (PyErr_Occurred()) SWIG_fail;
15046 }
15047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15048 return resultobj;
15049 fail:
15050 return NULL;
15051 }
15052
15053
15054 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15055 PyObject *resultobj;
15056 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 delete arg1;
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 Py_INCREF(Py_None); resultobj = Py_None;
15073 return resultobj;
15074 fail:
15075 return NULL;
15076 }
15077
15078
15079 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15080 PyObject *obj;
15081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15082 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15083 Py_INCREF(obj);
15084 return Py_BuildValue((char *)"");
15085 }
15086 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj;
15088 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15089 int arg2 = (int) 0 ;
15090 wxCommandEvent *result;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char *kwnames[] = {
15094 (char *) "commandType",(char *) "winid", NULL
15095 };
15096
15097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15098 if (obj0) {
15099 {
15100 arg1 = (wxEventType)(SWIG_As_int(obj0));
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 }
15103 }
15104 if (obj1) {
15105 {
15106 arg2 = (int)(SWIG_As_int(obj1));
15107 if (SWIG_arg_fail(2)) SWIG_fail;
15108 }
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15127 int result;
15128 PyObject * obj0 = 0 ;
15129 char *kwnames[] = {
15130 (char *) "self", NULL
15131 };
15132
15133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15135 if (SWIG_arg_fail(1)) SWIG_fail;
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 {
15144 resultobj = SWIG_From_int((int)(result));
15145 }
15146 return resultobj;
15147 fail:
15148 return NULL;
15149 }
15150
15151
15152 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj;
15154 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15155 wxString *arg2 = 0 ;
15156 bool temp2 = false ;
15157 PyObject * obj0 = 0 ;
15158 PyObject * obj1 = 0 ;
15159 char *kwnames[] = {
15160 (char *) "self",(char *) "s", NULL
15161 };
15162
15163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15165 if (SWIG_arg_fail(1)) SWIG_fail;
15166 {
15167 arg2 = wxString_in_helper(obj1);
15168 if (arg2 == NULL) SWIG_fail;
15169 temp2 = true;
15170 }
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 (arg1)->SetString((wxString const &)*arg2);
15174
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 Py_INCREF(Py_None); resultobj = Py_None;
15179 {
15180 if (temp2)
15181 delete arg2;
15182 }
15183 return resultobj;
15184 fail:
15185 {
15186 if (temp2)
15187 delete arg2;
15188 }
15189 return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj;
15195 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15196 wxString result;
15197 PyObject * obj0 = 0 ;
15198 char *kwnames[] = {
15199 (char *) "self", NULL
15200 };
15201
15202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15204 if (SWIG_arg_fail(1)) SWIG_fail;
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = ((wxCommandEvent const *)arg1)->GetString();
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 {
15213 #if wxUSE_UNICODE
15214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15215 #else
15216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15217 #endif
15218 }
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj;
15227 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15228 bool result;
15229 PyObject * obj0 = 0 ;
15230 char *kwnames[] = {
15231 (char *) "self", NULL
15232 };
15233
15234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15236 if (SWIG_arg_fail(1)) SWIG_fail;
15237 {
15238 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15240
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 {
15245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15246 }
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15254 PyObject *resultobj;
15255 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15256 bool result;
15257 PyObject * obj0 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 {
15273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15274 }
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15282 PyObject *resultobj;
15283 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15284 long arg2 ;
15285 PyObject * obj0 = 0 ;
15286 PyObject * obj1 = 0 ;
15287 char *kwnames[] = {
15288 (char *) "self",(char *) "extraLong", NULL
15289 };
15290
15291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15293 if (SWIG_arg_fail(1)) SWIG_fail;
15294 {
15295 arg2 = (long)(SWIG_As_long(obj1));
15296 if (SWIG_arg_fail(2)) SWIG_fail;
15297 }
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 (arg1)->SetExtraLong(arg2);
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 Py_INCREF(Py_None); resultobj = Py_None;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj;
15314 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15315 long result;
15316 PyObject * obj0 = 0 ;
15317 char *kwnames[] = {
15318 (char *) "self", NULL
15319 };
15320
15321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(1)) SWIG_fail;
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15327
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 {
15332 resultobj = SWIG_From_long((long)(result));
15333 }
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj;
15342 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15343 int arg2 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 char *kwnames[] = {
15347 (char *) "self",(char *) "i", NULL
15348 };
15349
15350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15352 if (SWIG_arg_fail(1)) SWIG_fail;
15353 {
15354 arg2 = (int)(SWIG_As_int(obj1));
15355 if (SWIG_arg_fail(2)) SWIG_fail;
15356 }
15357 {
15358 PyThreadState* __tstate = wxPyBeginAllowThreads();
15359 (arg1)->SetInt(arg2);
15360
15361 wxPyEndAllowThreads(__tstate);
15362 if (PyErr_Occurred()) SWIG_fail;
15363 }
15364 Py_INCREF(Py_None); resultobj = Py_None;
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15372 PyObject *resultobj;
15373 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15374 long result;
15375 PyObject * obj0 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self", NULL
15378 };
15379
15380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15386
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 {
15391 resultobj = SWIG_From_long((long)(result));
15392 }
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj;
15401 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15402 wxEvent *result;
15403 PyObject * obj0 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 {
15412 PyThreadState* __tstate = wxPyBeginAllowThreads();
15413 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15414
15415 wxPyEndAllowThreads(__tstate);
15416 if (PyErr_Occurred()) SWIG_fail;
15417 }
15418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15419 return resultobj;
15420 fail:
15421 return NULL;
15422 }
15423
15424
15425 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15426 PyObject *obj;
15427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15428 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15429 Py_INCREF(obj);
15430 return Py_BuildValue((char *)"");
15431 }
15432 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15433 PyObject *resultobj;
15434 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15435 int arg2 = (int) 0 ;
15436 wxNotifyEvent *result;
15437 PyObject * obj0 = 0 ;
15438 PyObject * obj1 = 0 ;
15439 char *kwnames[] = {
15440 (char *) "commandType",(char *) "winid", NULL
15441 };
15442
15443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15444 if (obj0) {
15445 {
15446 arg1 = (wxEventType)(SWIG_As_int(obj0));
15447 if (SWIG_arg_fail(1)) SWIG_fail;
15448 }
15449 }
15450 if (obj1) {
15451 {
15452 arg2 = (int)(SWIG_As_int(obj1));
15453 if (SWIG_arg_fail(2)) SWIG_fail;
15454 }
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15459
15460 wxPyEndAllowThreads(__tstate);
15461 if (PyErr_Occurred()) SWIG_fail;
15462 }
15463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj;
15472 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15473 PyObject * obj0 = 0 ;
15474 char *kwnames[] = {
15475 (char *) "self", NULL
15476 };
15477
15478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15480 if (SWIG_arg_fail(1)) SWIG_fail;
15481 {
15482 PyThreadState* __tstate = wxPyBeginAllowThreads();
15483 (arg1)->Veto();
15484
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 Py_INCREF(Py_None); resultobj = Py_None;
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj;
15497 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15498 PyObject * obj0 = 0 ;
15499 char *kwnames[] = {
15500 (char *) "self", NULL
15501 };
15502
15503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15505 if (SWIG_arg_fail(1)) SWIG_fail;
15506 {
15507 PyThreadState* __tstate = wxPyBeginAllowThreads();
15508 (arg1)->Allow();
15509
15510 wxPyEndAllowThreads(__tstate);
15511 if (PyErr_Occurred()) SWIG_fail;
15512 }
15513 Py_INCREF(Py_None); resultobj = Py_None;
15514 return resultobj;
15515 fail:
15516 return NULL;
15517 }
15518
15519
15520 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15521 PyObject *resultobj;
15522 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15523 bool result;
15524 PyObject * obj0 = 0 ;
15525 char *kwnames[] = {
15526 (char *) "self", NULL
15527 };
15528
15529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15531 if (SWIG_arg_fail(1)) SWIG_fail;
15532 {
15533 PyThreadState* __tstate = wxPyBeginAllowThreads();
15534 result = (bool)(arg1)->IsAllowed();
15535
15536 wxPyEndAllowThreads(__tstate);
15537 if (PyErr_Occurred()) SWIG_fail;
15538 }
15539 {
15540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15541 }
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15549 PyObject *obj;
15550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15551 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15552 Py_INCREF(obj);
15553 return Py_BuildValue((char *)"");
15554 }
15555 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15556 PyObject *resultobj;
15557 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15558 int arg2 = (int) 0 ;
15559 int arg3 = (int) 0 ;
15560 int arg4 = (int) 0 ;
15561 wxScrollEvent *result;
15562 PyObject * obj0 = 0 ;
15563 PyObject * obj1 = 0 ;
15564 PyObject * obj2 = 0 ;
15565 PyObject * obj3 = 0 ;
15566 char *kwnames[] = {
15567 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15568 };
15569
15570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15571 if (obj0) {
15572 {
15573 arg1 = (wxEventType)(SWIG_As_int(obj0));
15574 if (SWIG_arg_fail(1)) SWIG_fail;
15575 }
15576 }
15577 if (obj1) {
15578 {
15579 arg2 = (int)(SWIG_As_int(obj1));
15580 if (SWIG_arg_fail(2)) SWIG_fail;
15581 }
15582 }
15583 if (obj2) {
15584 {
15585 arg3 = (int)(SWIG_As_int(obj2));
15586 if (SWIG_arg_fail(3)) SWIG_fail;
15587 }
15588 }
15589 if (obj3) {
15590 {
15591 arg4 = (int)(SWIG_As_int(obj3));
15592 if (SWIG_arg_fail(4)) SWIG_fail;
15593 }
15594 }
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15598
15599 wxPyEndAllowThreads(__tstate);
15600 if (PyErr_Occurred()) SWIG_fail;
15601 }
15602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15603 return resultobj;
15604 fail:
15605 return NULL;
15606 }
15607
15608
15609 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15610 PyObject *resultobj;
15611 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15612 int result;
15613 PyObject * obj0 = 0 ;
15614 char *kwnames[] = {
15615 (char *) "self", NULL
15616 };
15617
15618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15620 if (SWIG_arg_fail(1)) SWIG_fail;
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15624
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 {
15629 resultobj = SWIG_From_int((int)(result));
15630 }
15631 return resultobj;
15632 fail:
15633 return NULL;
15634 }
15635
15636
15637 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj;
15639 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15640 int result;
15641 PyObject * obj0 = 0 ;
15642 char *kwnames[] = {
15643 (char *) "self", NULL
15644 };
15645
15646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15648 if (SWIG_arg_fail(1)) SWIG_fail;
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15652
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = SWIG_From_int((int)(result));
15658 }
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15666 PyObject *resultobj;
15667 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15668 int arg2 ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 char *kwnames[] = {
15672 (char *) "self",(char *) "orient", NULL
15673 };
15674
15675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15677 if (SWIG_arg_fail(1)) SWIG_fail;
15678 {
15679 arg2 = (int)(SWIG_As_int(obj1));
15680 if (SWIG_arg_fail(2)) SWIG_fail;
15681 }
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 (arg1)->SetOrientation(arg2);
15685
15686 wxPyEndAllowThreads(__tstate);
15687 if (PyErr_Occurred()) SWIG_fail;
15688 }
15689 Py_INCREF(Py_None); resultobj = Py_None;
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj;
15698 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15699 int arg2 ;
15700 PyObject * obj0 = 0 ;
15701 PyObject * obj1 = 0 ;
15702 char *kwnames[] = {
15703 (char *) "self",(char *) "pos", NULL
15704 };
15705
15706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15708 if (SWIG_arg_fail(1)) SWIG_fail;
15709 {
15710 arg2 = (int)(SWIG_As_int(obj1));
15711 if (SWIG_arg_fail(2)) SWIG_fail;
15712 }
15713 {
15714 PyThreadState* __tstate = wxPyBeginAllowThreads();
15715 (arg1)->SetPosition(arg2);
15716
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 Py_INCREF(Py_None); resultobj = Py_None;
15721 return resultobj;
15722 fail:
15723 return NULL;
15724 }
15725
15726
15727 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15728 PyObject *obj;
15729 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15730 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15731 Py_INCREF(obj);
15732 return Py_BuildValue((char *)"");
15733 }
15734 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15737 int arg2 = (int) 0 ;
15738 int arg3 = (int) 0 ;
15739 wxScrollWinEvent *result;
15740 PyObject * obj0 = 0 ;
15741 PyObject * obj1 = 0 ;
15742 PyObject * obj2 = 0 ;
15743 char *kwnames[] = {
15744 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15745 };
15746
15747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15748 if (obj0) {
15749 {
15750 arg1 = (wxEventType)(SWIG_As_int(obj0));
15751 if (SWIG_arg_fail(1)) SWIG_fail;
15752 }
15753 }
15754 if (obj1) {
15755 {
15756 arg2 = (int)(SWIG_As_int(obj1));
15757 if (SWIG_arg_fail(2)) SWIG_fail;
15758 }
15759 }
15760 if (obj2) {
15761 {
15762 arg3 = (int)(SWIG_As_int(obj2));
15763 if (SWIG_arg_fail(3)) SWIG_fail;
15764 }
15765 }
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15769
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15781 PyObject *resultobj;
15782 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15783 int result;
15784 PyObject * obj0 = 0 ;
15785 char *kwnames[] = {
15786 (char *) "self", NULL
15787 };
15788
15789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15791 if (SWIG_arg_fail(1)) SWIG_fail;
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15795
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 {
15800 resultobj = SWIG_From_int((int)(result));
15801 }
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj;
15810 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15811 int result;
15812 PyObject * obj0 = 0 ;
15813 char *kwnames[] = {
15814 (char *) "self", NULL
15815 };
15816
15817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15819 if (SWIG_arg_fail(1)) SWIG_fail;
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 {
15828 resultobj = SWIG_From_int((int)(result));
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15839 int arg2 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char *kwnames[] = {
15843 (char *) "self",(char *) "orient", NULL
15844 };
15845
15846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15848 if (SWIG_arg_fail(1)) SWIG_fail;
15849 {
15850 arg2 = (int)(SWIG_As_int(obj1));
15851 if (SWIG_arg_fail(2)) SWIG_fail;
15852 }
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 (arg1)->SetOrientation(arg2);
15856
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 Py_INCREF(Py_None); resultobj = Py_None;
15861 return resultobj;
15862 fail:
15863 return NULL;
15864 }
15865
15866
15867 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj;
15869 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15870 int arg2 ;
15871 PyObject * obj0 = 0 ;
15872 PyObject * obj1 = 0 ;
15873 char *kwnames[] = {
15874 (char *) "self",(char *) "pos", NULL
15875 };
15876
15877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15879 if (SWIG_arg_fail(1)) SWIG_fail;
15880 {
15881 arg2 = (int)(SWIG_As_int(obj1));
15882 if (SWIG_arg_fail(2)) SWIG_fail;
15883 }
15884 {
15885 PyThreadState* __tstate = wxPyBeginAllowThreads();
15886 (arg1)->SetPosition(arg2);
15887
15888 wxPyEndAllowThreads(__tstate);
15889 if (PyErr_Occurred()) SWIG_fail;
15890 }
15891 Py_INCREF(Py_None); resultobj = Py_None;
15892 return resultobj;
15893 fail:
15894 return NULL;
15895 }
15896
15897
15898 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15899 PyObject *obj;
15900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15901 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15902 Py_INCREF(obj);
15903 return Py_BuildValue((char *)"");
15904 }
15905 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15906 PyObject *resultobj;
15907 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15908 wxMouseEvent *result;
15909 PyObject * obj0 = 0 ;
15910 char *kwnames[] = {
15911 (char *) "mouseType", NULL
15912 };
15913
15914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15915 if (obj0) {
15916 {
15917 arg1 = (wxEventType)(SWIG_As_int(obj0));
15918 if (SWIG_arg_fail(1)) SWIG_fail;
15919 }
15920 }
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15924
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 {
15929 resultobj = wxPyMake_wxObject(result, 1);
15930 }
15931 return resultobj;
15932 fail:
15933 return NULL;
15934 }
15935
15936
15937 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15938 PyObject *resultobj;
15939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15940 bool result;
15941 PyObject * obj0 = 0 ;
15942 char *kwnames[] = {
15943 (char *) "self", NULL
15944 };
15945
15946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15948 if (SWIG_arg_fail(1)) SWIG_fail;
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15952
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 {
15957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15958 }
15959 return resultobj;
15960 fail:
15961 return NULL;
15962 }
15963
15964
15965 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15966 PyObject *resultobj;
15967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15968 int arg2 = (int) wxMOUSE_BTN_ANY ;
15969 bool result;
15970 PyObject * obj0 = 0 ;
15971 PyObject * obj1 = 0 ;
15972 char *kwnames[] = {
15973 (char *) "self",(char *) "but", NULL
15974 };
15975
15976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15978 if (SWIG_arg_fail(1)) SWIG_fail;
15979 if (obj1) {
15980 {
15981 arg2 = (int)(SWIG_As_int(obj1));
15982 if (SWIG_arg_fail(2)) SWIG_fail;
15983 }
15984 }
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 {
15993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15994 }
15995 return resultobj;
15996 fail:
15997 return NULL;
15998 }
15999
16000
16001 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16002 PyObject *resultobj;
16003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16004 int arg2 = (int) wxMOUSE_BTN_ANY ;
16005 bool result;
16006 PyObject * obj0 = 0 ;
16007 PyObject * obj1 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self",(char *) "but", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 if (obj1) {
16016 {
16017 arg2 = (int)(SWIG_As_int(obj1));
16018 if (SWIG_arg_fail(2)) SWIG_fail;
16019 }
16020 }
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16024
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 {
16029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16030 }
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj;
16039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16040 int arg2 = (int) wxMOUSE_BTN_ANY ;
16041 bool result;
16042 PyObject * obj0 = 0 ;
16043 PyObject * obj1 = 0 ;
16044 char *kwnames[] = {
16045 (char *) "self",(char *) "but", NULL
16046 };
16047
16048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16050 if (SWIG_arg_fail(1)) SWIG_fail;
16051 if (obj1) {
16052 {
16053 arg2 = (int)(SWIG_As_int(obj1));
16054 if (SWIG_arg_fail(2)) SWIG_fail;
16055 }
16056 }
16057 {
16058 PyThreadState* __tstate = wxPyBeginAllowThreads();
16059 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16060
16061 wxPyEndAllowThreads(__tstate);
16062 if (PyErr_Occurred()) SWIG_fail;
16063 }
16064 {
16065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16066 }
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16074 PyObject *resultobj;
16075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16076 int arg2 ;
16077 bool result;
16078 PyObject * obj0 = 0 ;
16079 PyObject * obj1 = 0 ;
16080 char *kwnames[] = {
16081 (char *) "self",(char *) "but", NULL
16082 };
16083
16084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16086 if (SWIG_arg_fail(1)) SWIG_fail;
16087 {
16088 arg2 = (int)(SWIG_As_int(obj1));
16089 if (SWIG_arg_fail(2)) SWIG_fail;
16090 }
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16094
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 {
16099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16100 }
16101 return resultobj;
16102 fail:
16103 return NULL;
16104 }
16105
16106
16107 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj;
16109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16110 int arg2 ;
16111 bool result;
16112 PyObject * obj0 = 0 ;
16113 PyObject * obj1 = 0 ;
16114 char *kwnames[] = {
16115 (char *) "self",(char *) "but", NULL
16116 };
16117
16118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16120 if (SWIG_arg_fail(1)) SWIG_fail;
16121 {
16122 arg2 = (int)(SWIG_As_int(obj1));
16123 if (SWIG_arg_fail(2)) SWIG_fail;
16124 }
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 {
16133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16134 }
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj;
16143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16144 int result;
16145 PyObject * obj0 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = SWIG_From_int((int)(result));
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj;
16171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16172 bool result;
16173 PyObject * obj0 = 0 ;
16174 char *kwnames[] = {
16175 (char *) "self", NULL
16176 };
16177
16178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16180 if (SWIG_arg_fail(1)) SWIG_fail;
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 {
16189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16190 }
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj;
16199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16200 bool result;
16201 PyObject * obj0 = 0 ;
16202 char *kwnames[] = {
16203 (char *) "self", NULL
16204 };
16205
16206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16208 if (SWIG_arg_fail(1)) SWIG_fail;
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 {
16217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16218 }
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16228 bool result;
16229 PyObject * obj0 = 0 ;
16230 char *kwnames[] = {
16231 (char *) "self", NULL
16232 };
16233
16234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16236 if (SWIG_arg_fail(1)) SWIG_fail;
16237 {
16238 PyThreadState* __tstate = wxPyBeginAllowThreads();
16239 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16240
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 {
16245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16246 }
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj;
16255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16256 bool result;
16257 PyObject * obj0 = 0 ;
16258 char *kwnames[] = {
16259 (char *) "self", NULL
16260 };
16261
16262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16264 if (SWIG_arg_fail(1)) SWIG_fail;
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16268
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 {
16273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16274 }
16275 return resultobj;
16276 fail:
16277 return NULL;
16278 }
16279
16280
16281 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16282 PyObject *resultobj;
16283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16284 bool result;
16285 PyObject * obj0 = 0 ;
16286 char *kwnames[] = {
16287 (char *) "self", NULL
16288 };
16289
16290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16292 if (SWIG_arg_fail(1)) SWIG_fail;
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16296
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 {
16301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16302 }
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj;
16311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16312 bool result;
16313 PyObject * obj0 = 0 ;
16314 char *kwnames[] = {
16315 (char *) "self", NULL
16316 };
16317
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 {
16329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16330 }
16331 return resultobj;
16332 fail:
16333 return NULL;
16334 }
16335
16336
16337 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16338 PyObject *resultobj;
16339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16340 bool result;
16341 PyObject * obj0 = 0 ;
16342 char *kwnames[] = {
16343 (char *) "self", NULL
16344 };
16345
16346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16348 if (SWIG_arg_fail(1)) SWIG_fail;
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 {
16357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16358 }
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16368 bool result;
16369 PyObject * obj0 = 0 ;
16370 char *kwnames[] = {
16371 (char *) "self", NULL
16372 };
16373
16374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16376 if (SWIG_arg_fail(1)) SWIG_fail;
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16380
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 {
16385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16386 }
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj;
16395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16396 bool result;
16397 PyObject * obj0 = 0 ;
16398 char *kwnames[] = {
16399 (char *) "self", NULL
16400 };
16401
16402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16404 if (SWIG_arg_fail(1)) SWIG_fail;
16405 {
16406 PyThreadState* __tstate = wxPyBeginAllowThreads();
16407 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16408
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16422 PyObject *resultobj;
16423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16424 bool result;
16425 PyObject * obj0 = 0 ;
16426 char *kwnames[] = {
16427 (char *) "self", NULL
16428 };
16429
16430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16432 if (SWIG_arg_fail(1)) SWIG_fail;
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16436
16437 wxPyEndAllowThreads(__tstate);
16438 if (PyErr_Occurred()) SWIG_fail;
16439 }
16440 {
16441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16442 }
16443 return resultobj;
16444 fail:
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj;
16451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16452 bool result;
16453 PyObject * obj0 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16470 }
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 {
16497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16498 }
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj;
16507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16508 bool result;
16509 PyObject * obj0 = 0 ;
16510 char *kwnames[] = {
16511 (char *) "self", NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16516 if (SWIG_arg_fail(1)) SWIG_fail;
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16520
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 bool result;
16537 PyObject * obj0 = 0 ;
16538 char *kwnames[] = {
16539 (char *) "self", NULL
16540 };
16541
16542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16544 if (SWIG_arg_fail(1)) SWIG_fail;
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16548
16549 wxPyEndAllowThreads(__tstate);
16550 if (PyErr_Occurred()) SWIG_fail;
16551 }
16552 {
16553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16554 }
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj;
16563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16564 bool result;
16565 PyObject * obj0 = 0 ;
16566 char *kwnames[] = {
16567 (char *) "self", NULL
16568 };
16569
16570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16572 if (SWIG_arg_fail(1)) SWIG_fail;
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (bool)(arg1)->LeftIsDown();
16576
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16582 }
16583 return resultobj;
16584 fail:
16585 return NULL;
16586 }
16587
16588
16589 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj;
16591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16592 bool result;
16593 PyObject * obj0 = 0 ;
16594 char *kwnames[] = {
16595 (char *) "self", NULL
16596 };
16597
16598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16600 if (SWIG_arg_fail(1)) SWIG_fail;
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 result = (bool)(arg1)->MiddleIsDown();
16604
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 {
16609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16610 }
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16618 PyObject *resultobj;
16619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16620 bool result;
16621 PyObject * obj0 = 0 ;
16622 char *kwnames[] = {
16623 (char *) "self", NULL
16624 };
16625
16626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16628 if (SWIG_arg_fail(1)) SWIG_fail;
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 result = (bool)(arg1)->RightIsDown();
16632
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16638 }
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj;
16647 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16648 bool result;
16649 PyObject * obj0 = 0 ;
16650 char *kwnames[] = {
16651 (char *) "self", NULL
16652 };
16653
16654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16656 if (SWIG_arg_fail(1)) SWIG_fail;
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16660
16661 wxPyEndAllowThreads(__tstate);
16662 if (PyErr_Occurred()) SWIG_fail;
16663 }
16664 {
16665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16666 }
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj;
16675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16676 bool result;
16677 PyObject * obj0 = 0 ;
16678 char *kwnames[] = {
16679 (char *) "self", NULL
16680 };
16681
16682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16684 if (SWIG_arg_fail(1)) SWIG_fail;
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16688
16689 wxPyEndAllowThreads(__tstate);
16690 if (PyErr_Occurred()) SWIG_fail;
16691 }
16692 {
16693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16694 }
16695 return resultobj;
16696 fail:
16697 return NULL;
16698 }
16699
16700
16701 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj;
16703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16704 bool result;
16705 PyObject * obj0 = 0 ;
16706 char *kwnames[] = {
16707 (char *) "self", NULL
16708 };
16709
16710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16712 if (SWIG_arg_fail(1)) SWIG_fail;
16713 {
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16716
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 {
16721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16722 }
16723 return resultobj;
16724 fail:
16725 return NULL;
16726 }
16727
16728
16729 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16730 PyObject *resultobj;
16731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16732 bool result;
16733 PyObject * obj0 = 0 ;
16734 char *kwnames[] = {
16735 (char *) "self", NULL
16736 };
16737
16738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16740 if (SWIG_arg_fail(1)) SWIG_fail;
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16744
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 {
16749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16750 }
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj;
16759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16760 wxPoint result;
16761 PyObject * obj0 = 0 ;
16762 char *kwnames[] = {
16763 (char *) "self", NULL
16764 };
16765
16766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16768 if (SWIG_arg_fail(1)) SWIG_fail;
16769 {
16770 PyThreadState* __tstate = wxPyBeginAllowThreads();
16771 result = (arg1)->GetPosition();
16772
16773 wxPyEndAllowThreads(__tstate);
16774 if (PyErr_Occurred()) SWIG_fail;
16775 }
16776 {
16777 wxPoint * resultptr;
16778 resultptr = new wxPoint((wxPoint &)(result));
16779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16780 }
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16790 long *arg2 = (long *) 0 ;
16791 long *arg3 = (long *) 0 ;
16792 long temp2 ;
16793 int res2 = 0 ;
16794 long temp3 ;
16795 int res3 = 0 ;
16796 PyObject * obj0 = 0 ;
16797 char *kwnames[] = {
16798 (char *) "self", NULL
16799 };
16800
16801 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16802 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16805 if (SWIG_arg_fail(1)) SWIG_fail;
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 (arg1)->GetPosition(arg2,arg3);
16809
16810 wxPyEndAllowThreads(__tstate);
16811 if (PyErr_Occurred()) SWIG_fail;
16812 }
16813 Py_INCREF(Py_None); resultobj = Py_None;
16814 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16815 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16816 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16817 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16818 return resultobj;
16819 fail:
16820 return NULL;
16821 }
16822
16823
16824 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16825 PyObject *resultobj;
16826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16827 wxDC *arg2 = 0 ;
16828 wxPoint result;
16829 PyObject * obj0 = 0 ;
16830 PyObject * obj1 = 0 ;
16831 char *kwnames[] = {
16832 (char *) "self",(char *) "dc", NULL
16833 };
16834
16835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16837 if (SWIG_arg_fail(1)) SWIG_fail;
16838 {
16839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16840 if (SWIG_arg_fail(2)) SWIG_fail;
16841 if (arg2 == NULL) {
16842 SWIG_null_ref("wxDC");
16843 }
16844 if (SWIG_arg_fail(2)) SWIG_fail;
16845 }
16846 {
16847 PyThreadState* __tstate = wxPyBeginAllowThreads();
16848 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16849
16850 wxPyEndAllowThreads(__tstate);
16851 if (PyErr_Occurred()) SWIG_fail;
16852 }
16853 {
16854 wxPoint * resultptr;
16855 resultptr = new wxPoint((wxPoint &)(result));
16856 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16857 }
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16867 int result;
16868 PyObject * obj0 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "self", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16875 if (SWIG_arg_fail(1)) SWIG_fail;
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (int)((wxMouseEvent const *)arg1)->GetX();
16879
16880 wxPyEndAllowThreads(__tstate);
16881 if (PyErr_Occurred()) SWIG_fail;
16882 }
16883 {
16884 resultobj = SWIG_From_int((int)(result));
16885 }
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj;
16894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16895 int result;
16896 PyObject * obj0 = 0 ;
16897 char *kwnames[] = {
16898 (char *) "self", NULL
16899 };
16900
16901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16903 if (SWIG_arg_fail(1)) SWIG_fail;
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (int)((wxMouseEvent const *)arg1)->GetY();
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 resultobj = SWIG_From_int((int)(result));
16913 }
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16921 PyObject *resultobj;
16922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16923 int result;
16924 PyObject * obj0 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "self", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16931 if (SWIG_arg_fail(1)) SWIG_fail;
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16935
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 {
16940 resultobj = SWIG_From_int((int)(result));
16941 }
16942 return resultobj;
16943 fail:
16944 return NULL;
16945 }
16946
16947
16948 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16949 PyObject *resultobj;
16950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16951 int result;
16952 PyObject * obj0 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 {
16961 PyThreadState* __tstate = wxPyBeginAllowThreads();
16962 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16963
16964 wxPyEndAllowThreads(__tstate);
16965 if (PyErr_Occurred()) SWIG_fail;
16966 }
16967 {
16968 resultobj = SWIG_From_int((int)(result));
16969 }
16970 return resultobj;
16971 fail:
16972 return NULL;
16973 }
16974
16975
16976 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16977 PyObject *resultobj;
16978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16979 int result;
16980 PyObject * obj0 = 0 ;
16981 char *kwnames[] = {
16982 (char *) "self", NULL
16983 };
16984
16985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16987 if (SWIG_arg_fail(1)) SWIG_fail;
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16991
16992 wxPyEndAllowThreads(__tstate);
16993 if (PyErr_Occurred()) SWIG_fail;
16994 }
16995 {
16996 resultobj = SWIG_From_int((int)(result));
16997 }
16998 return resultobj;
16999 fail:
17000 return NULL;
17001 }
17002
17003
17004 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17005 PyObject *resultobj;
17006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17007 bool result;
17008 PyObject * obj0 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "self", NULL
17011 };
17012
17013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17015 if (SWIG_arg_fail(1)) SWIG_fail;
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 {
17024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17025 }
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17033 PyObject *resultobj;
17034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17035 int arg2 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char *kwnames[] = {
17039 (char *) "self",(char *) "m_x", NULL
17040 };
17041
17042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17044 if (SWIG_arg_fail(1)) SWIG_fail;
17045 {
17046 arg2 = (int)(SWIG_As_int(obj1));
17047 if (SWIG_arg_fail(2)) SWIG_fail;
17048 }
17049 if (arg1) (arg1)->m_x = arg2;
17050
17051 Py_INCREF(Py_None); resultobj = Py_None;
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj;
17060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17061 int result;
17062 PyObject * obj0 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 result = (int) ((arg1)->m_x);
17071
17072 {
17073 resultobj = SWIG_From_int((int)(result));
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 int arg2 ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char *kwnames[] = {
17088 (char *) "self",(char *) "m_y", NULL
17089 };
17090
17091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17093 if (SWIG_arg_fail(1)) SWIG_fail;
17094 {
17095 arg2 = (int)(SWIG_As_int(obj1));
17096 if (SWIG_arg_fail(2)) SWIG_fail;
17097 }
17098 if (arg1) (arg1)->m_y = arg2;
17099
17100 Py_INCREF(Py_None); resultobj = Py_None;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17110 int result;
17111 PyObject * obj0 = 0 ;
17112 char *kwnames[] = {
17113 (char *) "self", NULL
17114 };
17115
17116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17118 if (SWIG_arg_fail(1)) SWIG_fail;
17119 result = (int) ((arg1)->m_y);
17120
17121 {
17122 resultobj = SWIG_From_int((int)(result));
17123 }
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17133 bool arg2 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 char *kwnames[] = {
17137 (char *) "self",(char *) "m_leftDown", NULL
17138 };
17139
17140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17142 if (SWIG_arg_fail(1)) SWIG_fail;
17143 {
17144 arg2 = (bool)(SWIG_As_bool(obj1));
17145 if (SWIG_arg_fail(2)) SWIG_fail;
17146 }
17147 if (arg1) (arg1)->m_leftDown = arg2;
17148
17149 Py_INCREF(Py_None); resultobj = Py_None;
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17157 PyObject *resultobj;
17158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17159 bool result;
17160 PyObject * obj0 = 0 ;
17161 char *kwnames[] = {
17162 (char *) "self", NULL
17163 };
17164
17165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17167 if (SWIG_arg_fail(1)) SWIG_fail;
17168 result = (bool) ((arg1)->m_leftDown);
17169
17170 {
17171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17172 }
17173 return resultobj;
17174 fail:
17175 return NULL;
17176 }
17177
17178
17179 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj;
17181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17182 bool arg2 ;
17183 PyObject * obj0 = 0 ;
17184 PyObject * obj1 = 0 ;
17185 char *kwnames[] = {
17186 (char *) "self",(char *) "m_middleDown", NULL
17187 };
17188
17189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 {
17193 arg2 = (bool)(SWIG_As_bool(obj1));
17194 if (SWIG_arg_fail(2)) SWIG_fail;
17195 }
17196 if (arg1) (arg1)->m_middleDown = arg2;
17197
17198 Py_INCREF(Py_None); resultobj = Py_None;
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17208 bool result;
17209 PyObject * obj0 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 result = (bool) ((arg1)->m_middleDown);
17218
17219 {
17220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17221 }
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17229 PyObject *resultobj;
17230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17231 bool arg2 ;
17232 PyObject * obj0 = 0 ;
17233 PyObject * obj1 = 0 ;
17234 char *kwnames[] = {
17235 (char *) "self",(char *) "m_rightDown", NULL
17236 };
17237
17238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17240 if (SWIG_arg_fail(1)) SWIG_fail;
17241 {
17242 arg2 = (bool)(SWIG_As_bool(obj1));
17243 if (SWIG_arg_fail(2)) SWIG_fail;
17244 }
17245 if (arg1) (arg1)->m_rightDown = arg2;
17246
17247 Py_INCREF(Py_None); resultobj = Py_None;
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 bool result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 result = (bool) ((arg1)->m_rightDown);
17267
17268 {
17269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17270 }
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17280 bool arg2 ;
17281 PyObject * obj0 = 0 ;
17282 PyObject * obj1 = 0 ;
17283 char *kwnames[] = {
17284 (char *) "self",(char *) "m_controlDown", NULL
17285 };
17286
17287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17289 if (SWIG_arg_fail(1)) SWIG_fail;
17290 {
17291 arg2 = (bool)(SWIG_As_bool(obj1));
17292 if (SWIG_arg_fail(2)) SWIG_fail;
17293 }
17294 if (arg1) (arg1)->m_controlDown = arg2;
17295
17296 Py_INCREF(Py_None); resultobj = Py_None;
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17304 PyObject *resultobj;
17305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17306 bool result;
17307 PyObject * obj0 = 0 ;
17308 char *kwnames[] = {
17309 (char *) "self", NULL
17310 };
17311
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 result = (bool) ((arg1)->m_controlDown);
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_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17327 PyObject *resultobj;
17328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17329 bool arg2 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char *kwnames[] = {
17333 (char *) "self",(char *) "m_shiftDown", NULL
17334 };
17335
17336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17338 if (SWIG_arg_fail(1)) SWIG_fail;
17339 {
17340 arg2 = (bool)(SWIG_As_bool(obj1));
17341 if (SWIG_arg_fail(2)) SWIG_fail;
17342 }
17343 if (arg1) (arg1)->m_shiftDown = arg2;
17344
17345 Py_INCREF(Py_None); resultobj = Py_None;
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj;
17354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17355 bool result;
17356 PyObject * obj0 = 0 ;
17357 char *kwnames[] = {
17358 (char *) "self", NULL
17359 };
17360
17361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17363 if (SWIG_arg_fail(1)) SWIG_fail;
17364 result = (bool) ((arg1)->m_shiftDown);
17365
17366 {
17367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj;
17377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17378 bool arg2 ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 char *kwnames[] = {
17382 (char *) "self",(char *) "m_altDown", NULL
17383 };
17384
17385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17387 if (SWIG_arg_fail(1)) SWIG_fail;
17388 {
17389 arg2 = (bool)(SWIG_As_bool(obj1));
17390 if (SWIG_arg_fail(2)) SWIG_fail;
17391 }
17392 if (arg1) (arg1)->m_altDown = arg2;
17393
17394 Py_INCREF(Py_None); resultobj = Py_None;
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 bool result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 result = (bool) ((arg1)->m_altDown);
17414
17415 {
17416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17425 PyObject *resultobj;
17426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17427 bool arg2 ;
17428 PyObject * obj0 = 0 ;
17429 PyObject * obj1 = 0 ;
17430 char *kwnames[] = {
17431 (char *) "self",(char *) "m_metaDown", NULL
17432 };
17433
17434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17436 if (SWIG_arg_fail(1)) SWIG_fail;
17437 {
17438 arg2 = (bool)(SWIG_As_bool(obj1));
17439 if (SWIG_arg_fail(2)) SWIG_fail;
17440 }
17441 if (arg1) (arg1)->m_metaDown = arg2;
17442
17443 Py_INCREF(Py_None); resultobj = Py_None;
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17451 PyObject *resultobj;
17452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17453 bool result;
17454 PyObject * obj0 = 0 ;
17455 char *kwnames[] = {
17456 (char *) "self", NULL
17457 };
17458
17459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17461 if (SWIG_arg_fail(1)) SWIG_fail;
17462 result = (bool) ((arg1)->m_metaDown);
17463
17464 {
17465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17466 }
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj;
17475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17476 int arg2 ;
17477 PyObject * obj0 = 0 ;
17478 PyObject * obj1 = 0 ;
17479 char *kwnames[] = {
17480 (char *) "self",(char *) "m_wheelRotation", NULL
17481 };
17482
17483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17485 if (SWIG_arg_fail(1)) SWIG_fail;
17486 {
17487 arg2 = (int)(SWIG_As_int(obj1));
17488 if (SWIG_arg_fail(2)) SWIG_fail;
17489 }
17490 if (arg1) (arg1)->m_wheelRotation = arg2;
17491
17492 Py_INCREF(Py_None); resultobj = Py_None;
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj;
17501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17502 int result;
17503 PyObject * obj0 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 result = (int) ((arg1)->m_wheelRotation);
17512
17513 {
17514 resultobj = SWIG_From_int((int)(result));
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj;
17524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17525 int arg2 ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 char *kwnames[] = {
17529 (char *) "self",(char *) "m_wheelDelta", NULL
17530 };
17531
17532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17534 if (SWIG_arg_fail(1)) SWIG_fail;
17535 {
17536 arg2 = (int)(SWIG_As_int(obj1));
17537 if (SWIG_arg_fail(2)) SWIG_fail;
17538 }
17539 if (arg1) (arg1)->m_wheelDelta = arg2;
17540
17541 Py_INCREF(Py_None); resultobj = Py_None;
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj;
17550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17551 int result;
17552 PyObject * obj0 = 0 ;
17553 char *kwnames[] = {
17554 (char *) "self", NULL
17555 };
17556
17557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17559 if (SWIG_arg_fail(1)) SWIG_fail;
17560 result = (int) ((arg1)->m_wheelDelta);
17561
17562 {
17563 resultobj = SWIG_From_int((int)(result));
17564 }
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj;
17573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17574 int arg2 ;
17575 PyObject * obj0 = 0 ;
17576 PyObject * obj1 = 0 ;
17577 char *kwnames[] = {
17578 (char *) "self",(char *) "m_linesPerAction", NULL
17579 };
17580
17581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17583 if (SWIG_arg_fail(1)) SWIG_fail;
17584 {
17585 arg2 = (int)(SWIG_As_int(obj1));
17586 if (SWIG_arg_fail(2)) SWIG_fail;
17587 }
17588 if (arg1) (arg1)->m_linesPerAction = arg2;
17589
17590 Py_INCREF(Py_None); resultobj = Py_None;
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj;
17599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17600 int result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 result = (int) ((arg1)->m_linesPerAction);
17610
17611 {
17612 resultobj = SWIG_From_int((int)(result));
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17621 PyObject *obj;
17622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17623 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17624 Py_INCREF(obj);
17625 return Py_BuildValue((char *)"");
17626 }
17627 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj;
17629 int arg1 = (int) 0 ;
17630 int arg2 = (int) 0 ;
17631 wxSetCursorEvent *result;
17632 PyObject * obj0 = 0 ;
17633 PyObject * obj1 = 0 ;
17634 char *kwnames[] = {
17635 (char *) "x",(char *) "y", NULL
17636 };
17637
17638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17639 if (obj0) {
17640 {
17641 arg1 = (int)(SWIG_As_int(obj0));
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 }
17644 }
17645 if (obj1) {
17646 {
17647 arg2 = (int)(SWIG_As_int(obj1));
17648 if (SWIG_arg_fail(2)) SWIG_fail;
17649 }
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17654
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17668 int result;
17669 PyObject * obj0 = 0 ;
17670 char *kwnames[] = {
17671 (char *) "self", NULL
17672 };
17673
17674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17676 if (SWIG_arg_fail(1)) SWIG_fail;
17677 {
17678 PyThreadState* __tstate = wxPyBeginAllowThreads();
17679 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17680
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 {
17685 resultobj = SWIG_From_int((int)(result));
17686 }
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17694 PyObject *resultobj;
17695 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17696 int result;
17697 PyObject * obj0 = 0 ;
17698 char *kwnames[] = {
17699 (char *) "self", NULL
17700 };
17701
17702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17704 if (SWIG_arg_fail(1)) SWIG_fail;
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17708
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 {
17713 resultobj = SWIG_From_int((int)(result));
17714 }
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17722 PyObject *resultobj;
17723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17724 wxCursor *arg2 = 0 ;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self",(char *) "cursor", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17736 if (SWIG_arg_fail(2)) SWIG_fail;
17737 if (arg2 == NULL) {
17738 SWIG_null_ref("wxCursor");
17739 }
17740 if (SWIG_arg_fail(2)) SWIG_fail;
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 (arg1)->SetCursor((wxCursor const &)*arg2);
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 Py_INCREF(Py_None); resultobj = Py_None;
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj;
17758 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17759 wxCursor *result;
17760 PyObject * obj0 = 0 ;
17761 char *kwnames[] = {
17762 (char *) "self", NULL
17763 };
17764
17765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17767 if (SWIG_arg_fail(1)) SWIG_fail;
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 {
17771 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17772 result = (wxCursor *) &_result_ref;
17773 }
17774
17775 wxPyEndAllowThreads(__tstate);
17776 if (PyErr_Occurred()) SWIG_fail;
17777 }
17778 {
17779 wxCursor* resultptr = new wxCursor(*result);
17780 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17781 }
17782 return resultobj;
17783 fail:
17784 return NULL;
17785 }
17786
17787
17788 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17789 PyObject *resultobj;
17790 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17791 bool result;
17792 PyObject * obj0 = 0 ;
17793 char *kwnames[] = {
17794 (char *) "self", NULL
17795 };
17796
17797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17799 if (SWIG_arg_fail(1)) SWIG_fail;
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17803
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 {
17808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17817 PyObject *obj;
17818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17819 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17820 Py_INCREF(obj);
17821 return Py_BuildValue((char *)"");
17822 }
17823 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj;
17825 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17826 wxKeyEvent *result;
17827 PyObject * obj0 = 0 ;
17828 char *kwnames[] = {
17829 (char *) "keyType", NULL
17830 };
17831
17832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17833 if (obj0) {
17834 {
17835 arg1 = (wxEventType)(SWIG_As_int(obj0));
17836 if (SWIG_arg_fail(1)) SWIG_fail;
17837 }
17838 }
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17842
17843 wxPyEndAllowThreads(__tstate);
17844 if (PyErr_Occurred()) SWIG_fail;
17845 }
17846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj;
17855 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17856 bool result;
17857 PyObject * obj0 = 0 ;
17858 char *kwnames[] = {
17859 (char *) "self", NULL
17860 };
17861
17862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17864 if (SWIG_arg_fail(1)) SWIG_fail;
17865 {
17866 PyThreadState* __tstate = wxPyBeginAllowThreads();
17867 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17868
17869 wxPyEndAllowThreads(__tstate);
17870 if (PyErr_Occurred()) SWIG_fail;
17871 }
17872 {
17873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17874 }
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17884 bool result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "self", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17892 if (SWIG_arg_fail(1)) SWIG_fail;
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17896
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17912 bool result;
17913 PyObject * obj0 = 0 ;
17914 char *kwnames[] = {
17915 (char *) "self", NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17920 if (SWIG_arg_fail(1)) SWIG_fail;
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 {
17929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17930 }
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17940 bool result;
17941 PyObject * obj0 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17952
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17968 bool result;
17969 PyObject * obj0 = 0 ;
17970 char *kwnames[] = {
17971 (char *) "self", NULL
17972 };
17973
17974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 {
17978 PyThreadState* __tstate = wxPyBeginAllowThreads();
17979 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17980
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 {
17985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17986 }
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj;
17995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17996 bool result;
17997 PyObject * obj0 = 0 ;
17998 char *kwnames[] = {
17999 (char *) "self", NULL
18000 };
18001
18002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18004 if (SWIG_arg_fail(1)) SWIG_fail;
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18008
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 {
18013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18014 }
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18022 PyObject *resultobj;
18023 wxKeyEvent *arg1 = (wxKeyEvent *) 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:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18032 if (SWIG_arg_fail(1)) SWIG_fail;
18033 {
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
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_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18050 PyObject *resultobj;
18051 wxKeyEvent *arg1 = (wxKeyEvent *) 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:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18060 if (SWIG_arg_fail(1)) SWIG_fail;
18061 {
18062 PyThreadState* __tstate = wxPyBeginAllowThreads();
18063 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
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_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj;
18079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18080 unsigned int result;
18081 PyObject * obj0 = 0 ;
18082 char *kwnames[] = {
18083 (char *) "self", NULL
18084 };
18085
18086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18088 if (SWIG_arg_fail(1)) SWIG_fail;
18089 {
18090 PyThreadState* __tstate = wxPyBeginAllowThreads();
18091 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18092
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 {
18097 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18098 }
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18106 PyObject *resultobj;
18107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18108 unsigned int result;
18109 PyObject * obj0 = 0 ;
18110 char *kwnames[] = {
18111 (char *) "self", NULL
18112 };
18113
18114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18116 if (SWIG_arg_fail(1)) SWIG_fail;
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18126 }
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj;
18135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18136 wxPoint result;
18137 PyObject * obj0 = 0 ;
18138 char *kwnames[] = {
18139 (char *) "self", NULL
18140 };
18141
18142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18144 if (SWIG_arg_fail(1)) SWIG_fail;
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (arg1)->GetPosition();
18148
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 {
18153 wxPoint * resultptr;
18154 resultptr = new wxPoint((wxPoint &)(result));
18155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18166 long *arg2 = (long *) 0 ;
18167 long *arg3 = (long *) 0 ;
18168 long temp2 ;
18169 int res2 = 0 ;
18170 long temp3 ;
18171 int res3 = 0 ;
18172 PyObject * obj0 = 0 ;
18173 char *kwnames[] = {
18174 (char *) "self", NULL
18175 };
18176
18177 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18178 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18181 if (SWIG_arg_fail(1)) SWIG_fail;
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 (arg1)->GetPosition(arg2,arg3);
18185
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 Py_INCREF(Py_None); resultobj = Py_None;
18190 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18191 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18192 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18193 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18194 return resultobj;
18195 fail:
18196 return NULL;
18197 }
18198
18199
18200 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18201 PyObject *resultobj;
18202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18203 int result;
18204 PyObject * obj0 = 0 ;
18205 char *kwnames[] = {
18206 (char *) "self", NULL
18207 };
18208
18209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18211 if (SWIG_arg_fail(1)) SWIG_fail;
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (int)((wxKeyEvent const *)arg1)->GetX();
18215
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 {
18220 resultobj = SWIG_From_int((int)(result));
18221 }
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj;
18230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18231 int result;
18232 PyObject * obj0 = 0 ;
18233 char *kwnames[] = {
18234 (char *) "self", NULL
18235 };
18236
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 result = (int)((wxKeyEvent const *)arg1)->GetY();
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 {
18248 resultobj = SWIG_From_int((int)(result));
18249 }
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj;
18258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18259 int arg2 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self",(char *) "m_x", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 {
18270 arg2 = (int)(SWIG_As_int(obj1));
18271 if (SWIG_arg_fail(2)) SWIG_fail;
18272 }
18273 if (arg1) (arg1)->m_x = arg2;
18274
18275 Py_INCREF(Py_None); resultobj = Py_None;
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18283 PyObject *resultobj;
18284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18285 int result;
18286 PyObject * obj0 = 0 ;
18287 char *kwnames[] = {
18288 (char *) "self", NULL
18289 };
18290
18291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18293 if (SWIG_arg_fail(1)) SWIG_fail;
18294 result = (int) ((arg1)->m_x);
18295
18296 {
18297 resultobj = SWIG_From_int((int)(result));
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj;
18307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18308 int arg2 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "m_y", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = (int)(SWIG_As_int(obj1));
18320 if (SWIG_arg_fail(2)) SWIG_fail;
18321 }
18322 if (arg1) (arg1)->m_y = arg2;
18323
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18334 int result;
18335 PyObject * obj0 = 0 ;
18336 char *kwnames[] = {
18337 (char *) "self", NULL
18338 };
18339
18340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18342 if (SWIG_arg_fail(1)) SWIG_fail;
18343 result = (int) ((arg1)->m_y);
18344
18345 {
18346 resultobj = SWIG_From_int((int)(result));
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj;
18356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18357 long arg2 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self",(char *) "m_keyCode", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 arg2 = (long)(SWIG_As_long(obj1));
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (arg1) (arg1)->m_keyCode = arg2;
18372
18373 Py_INCREF(Py_None); resultobj = Py_None;
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18383 long result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 result = (long) ((arg1)->m_keyCode);
18393
18394 {
18395 resultobj = SWIG_From_long((long)(result));
18396 }
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18406 bool arg2 ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self",(char *) "m_controlDown", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 {
18417 arg2 = (bool)(SWIG_As_bool(obj1));
18418 if (SWIG_arg_fail(2)) SWIG_fail;
18419 }
18420 if (arg1) (arg1)->m_controlDown = arg2;
18421
18422 Py_INCREF(Py_None); resultobj = Py_None;
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 result = (bool) ((arg1)->m_controlDown);
18442
18443 {
18444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18445 }
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj;
18454 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18455 bool arg2 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "m_shiftDown", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = (bool)(SWIG_As_bool(obj1));
18467 if (SWIG_arg_fail(2)) SWIG_fail;
18468 }
18469 if (arg1) (arg1)->m_shiftDown = arg2;
18470
18471 Py_INCREF(Py_None); resultobj = Py_None;
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj;
18480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18481 bool result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 result = (bool) ((arg1)->m_shiftDown);
18491
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj;
18503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18504 bool arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "m_altDown", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = (bool)(SWIG_As_bool(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 if (arg1) (arg1)->m_altDown = arg2;
18519
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj;
18529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18530 bool result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 result = (bool) ((arg1)->m_altDown);
18540
18541 {
18542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18551 PyObject *resultobj;
18552 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18553 bool arg2 ;
18554 PyObject * obj0 = 0 ;
18555 PyObject * obj1 = 0 ;
18556 char *kwnames[] = {
18557 (char *) "self",(char *) "m_metaDown", NULL
18558 };
18559
18560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18562 if (SWIG_arg_fail(1)) SWIG_fail;
18563 {
18564 arg2 = (bool)(SWIG_As_bool(obj1));
18565 if (SWIG_arg_fail(2)) SWIG_fail;
18566 }
18567 if (arg1) (arg1)->m_metaDown = arg2;
18568
18569 Py_INCREF(Py_None); resultobj = Py_None;
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18579 bool result;
18580 PyObject * obj0 = 0 ;
18581 char *kwnames[] = {
18582 (char *) "self", NULL
18583 };
18584
18585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 result = (bool) ((arg1)->m_metaDown);
18589
18590 {
18591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18592 }
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj;
18601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18602 bool arg2 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "self",(char *) "m_scanCode", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18611 if (SWIG_arg_fail(1)) SWIG_fail;
18612 {
18613 arg2 = (bool)(SWIG_As_bool(obj1));
18614 if (SWIG_arg_fail(2)) SWIG_fail;
18615 }
18616 if (arg1) (arg1)->m_scanCode = arg2;
18617
18618 Py_INCREF(Py_None); resultobj = Py_None;
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18628 bool result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 result = (bool) ((arg1)->m_scanCode);
18638
18639 {
18640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18641 }
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj;
18650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18651 unsigned int arg2 ;
18652 PyObject * obj0 = 0 ;
18653 PyObject * obj1 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self",(char *) "m_rawCode", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 {
18662 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18663 if (SWIG_arg_fail(2)) SWIG_fail;
18664 }
18665 if (arg1) (arg1)->m_rawCode = arg2;
18666
18667 Py_INCREF(Py_None); resultobj = Py_None;
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18677 unsigned int result;
18678 PyObject * obj0 = 0 ;
18679 char *kwnames[] = {
18680 (char *) "self", NULL
18681 };
18682
18683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18685 if (SWIG_arg_fail(1)) SWIG_fail;
18686 result = (unsigned int) ((arg1)->m_rawCode);
18687
18688 {
18689 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18690 }
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18698 PyObject *resultobj;
18699 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18700 unsigned int arg2 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self",(char *) "m_rawFlags", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 {
18711 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 }
18714 if (arg1) (arg1)->m_rawFlags = arg2;
18715
18716 Py_INCREF(Py_None); resultobj = Py_None;
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj;
18725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18726 unsigned int result;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 result = (unsigned int) ((arg1)->m_rawFlags);
18736
18737 {
18738 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18739 }
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18747 PyObject *obj;
18748 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18749 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18750 Py_INCREF(obj);
18751 return Py_BuildValue((char *)"");
18752 }
18753 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj;
18755 wxSize const &arg1_defvalue = wxDefaultSize ;
18756 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18757 int arg2 = (int) 0 ;
18758 wxSizeEvent *result;
18759 wxSize temp1 ;
18760 PyObject * obj0 = 0 ;
18761 PyObject * obj1 = 0 ;
18762 char *kwnames[] = {
18763 (char *) "sz",(char *) "winid", NULL
18764 };
18765
18766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18767 if (obj0) {
18768 {
18769 arg1 = &temp1;
18770 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18771 }
18772 }
18773 if (obj1) {
18774 {
18775 arg2 = (int)(SWIG_As_int(obj1));
18776 if (SWIG_arg_fail(2)) SWIG_fail;
18777 }
18778 }
18779 {
18780 PyThreadState* __tstate = wxPyBeginAllowThreads();
18781 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18782
18783 wxPyEndAllowThreads(__tstate);
18784 if (PyErr_Occurred()) SWIG_fail;
18785 }
18786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj;
18795 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18796 wxSize result;
18797 PyObject * obj0 = 0 ;
18798 char *kwnames[] = {
18799 (char *) "self", NULL
18800 };
18801
18802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18804 if (SWIG_arg_fail(1)) SWIG_fail;
18805 {
18806 PyThreadState* __tstate = wxPyBeginAllowThreads();
18807 result = ((wxSizeEvent const *)arg1)->GetSize();
18808
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 {
18813 wxSize * resultptr;
18814 resultptr = new wxSize((wxSize &)(result));
18815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18816 }
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18826 wxRect result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = ((wxSizeEvent const *)arg1)->GetRect();
18838
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 {
18843 wxRect * resultptr;
18844 resultptr = new wxRect((wxRect &)(result));
18845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18846 }
18847 return resultobj;
18848 fail:
18849 return NULL;
18850 }
18851
18852
18853 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18854 PyObject *resultobj;
18855 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18856 wxRect arg2 ;
18857 PyObject * obj0 = 0 ;
18858 PyObject * obj1 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "self",(char *) "rect", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18865 if (SWIG_arg_fail(1)) SWIG_fail;
18866 {
18867 wxRect * argp;
18868 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18869 if (SWIG_arg_fail(2)) SWIG_fail;
18870 if (argp == NULL) {
18871 SWIG_null_ref("wxRect");
18872 }
18873 if (SWIG_arg_fail(2)) SWIG_fail;
18874 arg2 = *argp;
18875 }
18876 {
18877 PyThreadState* __tstate = wxPyBeginAllowThreads();
18878 (arg1)->SetRect(arg2);
18879
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 Py_INCREF(Py_None); resultobj = Py_None;
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18891 PyObject *resultobj;
18892 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18893 wxSize arg2 ;
18894 PyObject * obj0 = 0 ;
18895 PyObject * obj1 = 0 ;
18896 char *kwnames[] = {
18897 (char *) "self",(char *) "size", NULL
18898 };
18899
18900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18902 if (SWIG_arg_fail(1)) SWIG_fail;
18903 {
18904 wxSize * argp;
18905 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18906 if (SWIG_arg_fail(2)) SWIG_fail;
18907 if (argp == NULL) {
18908 SWIG_null_ref("wxSize");
18909 }
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 arg2 = *argp;
18912 }
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 wxSizeEvent_SetSize(arg1,arg2);
18916
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 Py_INCREF(Py_None); resultobj = Py_None;
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj;
18929 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18930 wxSize *arg2 = (wxSize *) 0 ;
18931 PyObject * obj0 = 0 ;
18932 PyObject * obj1 = 0 ;
18933 char *kwnames[] = {
18934 (char *) "self",(char *) "m_size", NULL
18935 };
18936
18937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18939 if (SWIG_arg_fail(1)) SWIG_fail;
18940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18941 if (SWIG_arg_fail(2)) SWIG_fail;
18942 if (arg1) (arg1)->m_size = *arg2;
18943
18944 Py_INCREF(Py_None); resultobj = Py_None;
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18952 PyObject *resultobj;
18953 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18954 wxSize *result;
18955 PyObject * obj0 = 0 ;
18956 char *kwnames[] = {
18957 (char *) "self", NULL
18958 };
18959
18960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18962 if (SWIG_arg_fail(1)) SWIG_fail;
18963 result = (wxSize *)& ((arg1)->m_size);
18964
18965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18966 return resultobj;
18967 fail:
18968 return NULL;
18969 }
18970
18971
18972 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18973 PyObject *resultobj;
18974 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18975 wxRect *arg2 = (wxRect *) 0 ;
18976 PyObject * obj0 = 0 ;
18977 PyObject * obj1 = 0 ;
18978 char *kwnames[] = {
18979 (char *) "self",(char *) "m_rect", NULL
18980 };
18981
18982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18984 if (SWIG_arg_fail(1)) SWIG_fail;
18985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18986 if (SWIG_arg_fail(2)) SWIG_fail;
18987 if (arg1) (arg1)->m_rect = *arg2;
18988
18989 Py_INCREF(Py_None); resultobj = Py_None;
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj;
18998 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18999 wxRect *result;
19000 PyObject * obj0 = 0 ;
19001 char *kwnames[] = {
19002 (char *) "self", NULL
19003 };
19004
19005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19007 if (SWIG_arg_fail(1)) SWIG_fail;
19008 result = (wxRect *)& ((arg1)->m_rect);
19009
19010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19011 return resultobj;
19012 fail:
19013 return NULL;
19014 }
19015
19016
19017 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19018 PyObject *obj;
19019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19020 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19021 Py_INCREF(obj);
19022 return Py_BuildValue((char *)"");
19023 }
19024 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19025 PyObject *resultobj;
19026 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19027 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19028 int arg2 = (int) 0 ;
19029 wxMoveEvent *result;
19030 wxPoint temp1 ;
19031 PyObject * obj0 = 0 ;
19032 PyObject * obj1 = 0 ;
19033 char *kwnames[] = {
19034 (char *) "pos",(char *) "winid", NULL
19035 };
19036
19037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19038 if (obj0) {
19039 {
19040 arg1 = &temp1;
19041 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19042 }
19043 }
19044 if (obj1) {
19045 {
19046 arg2 = (int)(SWIG_As_int(obj1));
19047 if (SWIG_arg_fail(2)) SWIG_fail;
19048 }
19049 }
19050 {
19051 PyThreadState* __tstate = wxPyBeginAllowThreads();
19052 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19053
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19058 return resultobj;
19059 fail:
19060 return NULL;
19061 }
19062
19063
19064 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19065 PyObject *resultobj;
19066 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19067 wxPoint result;
19068 PyObject * obj0 = 0 ;
19069 char *kwnames[] = {
19070 (char *) "self", NULL
19071 };
19072
19073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19075 if (SWIG_arg_fail(1)) SWIG_fail;
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 result = ((wxMoveEvent const *)arg1)->GetPosition();
19079
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 {
19084 wxPoint * resultptr;
19085 resultptr = new wxPoint((wxPoint &)(result));
19086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19087 }
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19095 PyObject *resultobj;
19096 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19097 wxRect result;
19098 PyObject * obj0 = 0 ;
19099 char *kwnames[] = {
19100 (char *) "self", NULL
19101 };
19102
19103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19105 if (SWIG_arg_fail(1)) SWIG_fail;
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 result = ((wxMoveEvent const *)arg1)->GetRect();
19109
19110 wxPyEndAllowThreads(__tstate);
19111 if (PyErr_Occurred()) SWIG_fail;
19112 }
19113 {
19114 wxRect * resultptr;
19115 resultptr = new wxRect((wxRect &)(result));
19116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19117 }
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj;
19126 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19127 wxRect *arg2 = 0 ;
19128 wxRect temp2 ;
19129 PyObject * obj0 = 0 ;
19130 PyObject * obj1 = 0 ;
19131 char *kwnames[] = {
19132 (char *) "self",(char *) "rect", NULL
19133 };
19134
19135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19137 if (SWIG_arg_fail(1)) SWIG_fail;
19138 {
19139 arg2 = &temp2;
19140 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19141 }
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 (arg1)->SetRect((wxRect const &)*arg2);
19145
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 Py_INCREF(Py_None); resultobj = Py_None;
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj;
19158 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19159 wxPoint *arg2 = 0 ;
19160 wxPoint temp2 ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char *kwnames[] = {
19164 (char *) "self",(char *) "pos", NULL
19165 };
19166
19167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19169 if (SWIG_arg_fail(1)) SWIG_fail;
19170 {
19171 arg2 = &temp2;
19172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19173 }
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 (arg1)->SetPosition((wxPoint const &)*arg2);
19177
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 Py_INCREF(Py_None); resultobj = Py_None;
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19189 PyObject *obj;
19190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19191 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19192 Py_INCREF(obj);
19193 return Py_BuildValue((char *)"");
19194 }
19195 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj;
19197 int arg1 = (int) 0 ;
19198 wxPaintEvent *result;
19199 PyObject * obj0 = 0 ;
19200 char *kwnames[] = {
19201 (char *) "Id", NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19205 if (obj0) {
19206 {
19207 arg1 = (int)(SWIG_As_int(obj0));
19208 if (SWIG_arg_fail(1)) SWIG_fail;
19209 }
19210 }
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19214
19215 wxPyEndAllowThreads(__tstate);
19216 if (PyErr_Occurred()) SWIG_fail;
19217 }
19218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19219 return resultobj;
19220 fail:
19221 return NULL;
19222 }
19223
19224
19225 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19226 PyObject *obj;
19227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19228 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19229 Py_INCREF(obj);
19230 return Py_BuildValue((char *)"");
19231 }
19232 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 int arg1 = (int) 0 ;
19235 wxNcPaintEvent *result;
19236 PyObject * obj0 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "winid", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19242 if (obj0) {
19243 {
19244 arg1 = (int)(SWIG_As_int(obj0));
19245 if (SWIG_arg_fail(1)) SWIG_fail;
19246 }
19247 }
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19256 return resultobj;
19257 fail:
19258 return NULL;
19259 }
19260
19261
19262 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19263 PyObject *obj;
19264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19265 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19266 Py_INCREF(obj);
19267 return Py_BuildValue((char *)"");
19268 }
19269 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19270 PyObject *resultobj;
19271 int arg1 = (int) 0 ;
19272 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19273 wxEraseEvent *result;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char *kwnames[] = {
19277 (char *) "Id",(char *) "dc", NULL
19278 };
19279
19280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19281 if (obj0) {
19282 {
19283 arg1 = (int)(SWIG_As_int(obj0));
19284 if (SWIG_arg_fail(1)) SWIG_fail;
19285 }
19286 }
19287 if (obj1) {
19288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19289 if (SWIG_arg_fail(2)) SWIG_fail;
19290 }
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19294
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19306 PyObject *resultobj;
19307 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19308 wxDC *result;
19309 PyObject * obj0 = 0 ;
19310 char *kwnames[] = {
19311 (char *) "self", NULL
19312 };
19313
19314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19316 if (SWIG_arg_fail(1)) SWIG_fail;
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19320
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 {
19325 resultobj = wxPyMake_wxObject(result, 0);
19326 }
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19334 PyObject *obj;
19335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19336 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19337 Py_INCREF(obj);
19338 return Py_BuildValue((char *)"");
19339 }
19340 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19341 PyObject *resultobj;
19342 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19343 int arg2 = (int) 0 ;
19344 wxFocusEvent *result;
19345 PyObject * obj0 = 0 ;
19346 PyObject * obj1 = 0 ;
19347 char *kwnames[] = {
19348 (char *) "type",(char *) "winid", NULL
19349 };
19350
19351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19352 if (obj0) {
19353 {
19354 arg1 = (wxEventType)(SWIG_As_int(obj0));
19355 if (SWIG_arg_fail(1)) SWIG_fail;
19356 }
19357 }
19358 if (obj1) {
19359 {
19360 arg2 = (int)(SWIG_As_int(obj1));
19361 if (SWIG_arg_fail(2)) SWIG_fail;
19362 }
19363 }
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19367
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj;
19380 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19381 wxWindow *result;
19382 PyObject * obj0 = 0 ;
19383 char *kwnames[] = {
19384 (char *) "self", NULL
19385 };
19386
19387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19393
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 {
19398 resultobj = wxPyMake_wxObject(result, 0);
19399 }
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj;
19408 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19409 wxWindow *arg2 = (wxWindow *) 0 ;
19410 PyObject * obj0 = 0 ;
19411 PyObject * obj1 = 0 ;
19412 char *kwnames[] = {
19413 (char *) "self",(char *) "win", NULL
19414 };
19415
19416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19418 if (SWIG_arg_fail(1)) SWIG_fail;
19419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19420 if (SWIG_arg_fail(2)) SWIG_fail;
19421 {
19422 PyThreadState* __tstate = wxPyBeginAllowThreads();
19423 (arg1)->SetWindow(arg2);
19424
19425 wxPyEndAllowThreads(__tstate);
19426 if (PyErr_Occurred()) SWIG_fail;
19427 }
19428 Py_INCREF(Py_None); resultobj = Py_None;
19429 return resultobj;
19430 fail:
19431 return NULL;
19432 }
19433
19434
19435 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19436 PyObject *obj;
19437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19438 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19439 Py_INCREF(obj);
19440 return Py_BuildValue((char *)"");
19441 }
19442 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19443 PyObject *resultobj;
19444 wxWindow *arg1 = (wxWindow *) NULL ;
19445 wxChildFocusEvent *result;
19446 PyObject * obj0 = 0 ;
19447 char *kwnames[] = {
19448 (char *) "win", NULL
19449 };
19450
19451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19452 if (obj0) {
19453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 }
19456 {
19457 PyThreadState* __tstate = wxPyBeginAllowThreads();
19458 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19459
19460 wxPyEndAllowThreads(__tstate);
19461 if (PyErr_Occurred()) SWIG_fail;
19462 }
19463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19464 return resultobj;
19465 fail:
19466 return NULL;
19467 }
19468
19469
19470 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19471 PyObject *resultobj;
19472 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19473 wxWindow *result;
19474 PyObject * obj0 = 0 ;
19475 char *kwnames[] = {
19476 (char *) "self", NULL
19477 };
19478
19479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19485
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 {
19490 resultobj = wxPyMake_wxObject(result, 0);
19491 }
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19499 PyObject *obj;
19500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19501 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19502 Py_INCREF(obj);
19503 return Py_BuildValue((char *)"");
19504 }
19505 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19508 bool arg2 = (bool) true ;
19509 int arg3 = (int) 0 ;
19510 wxActivateEvent *result;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 PyObject * obj2 = 0 ;
19514 char *kwnames[] = {
19515 (char *) "type",(char *) "active",(char *) "Id", NULL
19516 };
19517
19518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19519 if (obj0) {
19520 {
19521 arg1 = (wxEventType)(SWIG_As_int(obj0));
19522 if (SWIG_arg_fail(1)) SWIG_fail;
19523 }
19524 }
19525 if (obj1) {
19526 {
19527 arg2 = (bool)(SWIG_As_bool(obj1));
19528 if (SWIG_arg_fail(2)) SWIG_fail;
19529 }
19530 }
19531 if (obj2) {
19532 {
19533 arg3 = (int)(SWIG_As_int(obj2));
19534 if (SWIG_arg_fail(3)) SWIG_fail;
19535 }
19536 }
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19540
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19552 PyObject *resultobj;
19553 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19554 bool result;
19555 PyObject * obj0 = 0 ;
19556 char *kwnames[] = {
19557 (char *) "self", NULL
19558 };
19559
19560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 {
19571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19572 }
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19580 PyObject *obj;
19581 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19582 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19583 Py_INCREF(obj);
19584 return Py_BuildValue((char *)"");
19585 }
19586 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 int arg1 = (int) 0 ;
19589 wxInitDialogEvent *result;
19590 PyObject * obj0 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "Id", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19596 if (obj0) {
19597 {
19598 arg1 = (int)(SWIG_As_int(obj0));
19599 if (SWIG_arg_fail(1)) SWIG_fail;
19600 }
19601 }
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19605
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19617 PyObject *obj;
19618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19619 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19620 Py_INCREF(obj);
19621 return Py_BuildValue((char *)"");
19622 }
19623 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19624 PyObject *resultobj;
19625 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19626 int arg2 = (int) 0 ;
19627 wxMenu *arg3 = (wxMenu *) NULL ;
19628 wxMenuEvent *result;
19629 PyObject * obj0 = 0 ;
19630 PyObject * obj1 = 0 ;
19631 PyObject * obj2 = 0 ;
19632 char *kwnames[] = {
19633 (char *) "type",(char *) "winid",(char *) "menu", NULL
19634 };
19635
19636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19637 if (obj0) {
19638 {
19639 arg1 = (wxEventType)(SWIG_As_int(obj0));
19640 if (SWIG_arg_fail(1)) SWIG_fail;
19641 }
19642 }
19643 if (obj1) {
19644 {
19645 arg2 = (int)(SWIG_As_int(obj1));
19646 if (SWIG_arg_fail(2)) SWIG_fail;
19647 }
19648 }
19649 if (obj2) {
19650 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19651 if (SWIG_arg_fail(3)) SWIG_fail;
19652 }
19653 {
19654 PyThreadState* __tstate = wxPyBeginAllowThreads();
19655 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19656
19657 wxPyEndAllowThreads(__tstate);
19658 if (PyErr_Occurred()) SWIG_fail;
19659 }
19660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19661 return resultobj;
19662 fail:
19663 return NULL;
19664 }
19665
19666
19667 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19668 PyObject *resultobj;
19669 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19670 int result;
19671 PyObject * obj0 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 PyThreadState* __tstate = wxPyBeginAllowThreads();
19681 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19682
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 {
19687 resultobj = SWIG_From_int((int)(result));
19688 }
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19696 PyObject *resultobj;
19697 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19698 bool result;
19699 PyObject * obj0 = 0 ;
19700 char *kwnames[] = {
19701 (char *) "self", NULL
19702 };
19703
19704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19706 if (SWIG_arg_fail(1)) SWIG_fail;
19707 {
19708 PyThreadState* __tstate = wxPyBeginAllowThreads();
19709 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19710
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 {
19715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19716 }
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj;
19725 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19726 wxMenu *result;
19727 PyObject * obj0 = 0 ;
19728 char *kwnames[] = {
19729 (char *) "self", NULL
19730 };
19731
19732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19734 if (SWIG_arg_fail(1)) SWIG_fail;
19735 {
19736 PyThreadState* __tstate = wxPyBeginAllowThreads();
19737 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19738
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 {
19743 resultobj = wxPyMake_wxObject(result, 0);
19744 }
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19752 PyObject *obj;
19753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19754 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19755 Py_INCREF(obj);
19756 return Py_BuildValue((char *)"");
19757 }
19758 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19759 PyObject *resultobj;
19760 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19761 int arg2 = (int) 0 ;
19762 wxCloseEvent *result;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "type",(char *) "winid", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19770 if (obj0) {
19771 {
19772 arg1 = (wxEventType)(SWIG_As_int(obj0));
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 }
19775 }
19776 if (obj1) {
19777 {
19778 arg2 = (int)(SWIG_As_int(obj1));
19779 if (SWIG_arg_fail(2)) SWIG_fail;
19780 }
19781 }
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19785
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19799 bool arg2 ;
19800 PyObject * obj0 = 0 ;
19801 PyObject * obj1 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self",(char *) "logOff", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 arg2 = (bool)(SWIG_As_bool(obj1));
19811 if (SWIG_arg_fail(2)) SWIG_fail;
19812 }
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 (arg1)->SetLoggingOff(arg2);
19816
19817 wxPyEndAllowThreads(__tstate);
19818 if (PyErr_Occurred()) SWIG_fail;
19819 }
19820 Py_INCREF(Py_None); resultobj = Py_None;
19821 return resultobj;
19822 fail:
19823 return NULL;
19824 }
19825
19826
19827 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19828 PyObject *resultobj;
19829 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19830 bool result;
19831 PyObject * obj0 = 0 ;
19832 char *kwnames[] = {
19833 (char *) "self", NULL
19834 };
19835
19836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19838 if (SWIG_arg_fail(1)) SWIG_fail;
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19842
19843 wxPyEndAllowThreads(__tstate);
19844 if (PyErr_Occurred()) SWIG_fail;
19845 }
19846 {
19847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19848 }
19849 return resultobj;
19850 fail:
19851 return NULL;
19852 }
19853
19854
19855 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19856 PyObject *resultobj;
19857 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19858 bool arg2 = (bool) true ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char *kwnames[] = {
19862 (char *) "self",(char *) "veto", NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19867 if (SWIG_arg_fail(1)) SWIG_fail;
19868 if (obj1) {
19869 {
19870 arg2 = (bool)(SWIG_As_bool(obj1));
19871 if (SWIG_arg_fail(2)) SWIG_fail;
19872 }
19873 }
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 (arg1)->Veto(arg2);
19877
19878 wxPyEndAllowThreads(__tstate);
19879 if (PyErr_Occurred()) SWIG_fail;
19880 }
19881 Py_INCREF(Py_None); resultobj = Py_None;
19882 return resultobj;
19883 fail:
19884 return NULL;
19885 }
19886
19887
19888 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19889 PyObject *resultobj;
19890 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19891 bool arg2 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char *kwnames[] = {
19895 (char *) "self",(char *) "canVeto", NULL
19896 };
19897
19898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19900 if (SWIG_arg_fail(1)) SWIG_fail;
19901 {
19902 arg2 = (bool)(SWIG_As_bool(obj1));
19903 if (SWIG_arg_fail(2)) SWIG_fail;
19904 }
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 (arg1)->SetCanVeto(arg2);
19908
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 Py_INCREF(Py_None); resultobj = Py_None;
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19920 PyObject *resultobj;
19921 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19922 bool result;
19923 PyObject * obj0 = 0 ;
19924 char *kwnames[] = {
19925 (char *) "self", NULL
19926 };
19927
19928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19930 if (SWIG_arg_fail(1)) SWIG_fail;
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 {
19939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19940 }
19941 return resultobj;
19942 fail:
19943 return NULL;
19944 }
19945
19946
19947 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj;
19949 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19950 bool result;
19951 PyObject * obj0 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19962
19963 wxPyEndAllowThreads(__tstate);
19964 if (PyErr_Occurred()) SWIG_fail;
19965 }
19966 {
19967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19968 }
19969 return resultobj;
19970 fail:
19971 return NULL;
19972 }
19973
19974
19975 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19976 PyObject *obj;
19977 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19978 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19979 Py_INCREF(obj);
19980 return Py_BuildValue((char *)"");
19981 }
19982 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj;
19984 int arg1 = (int) 0 ;
19985 bool arg2 = (bool) false ;
19986 wxShowEvent *result;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char *kwnames[] = {
19990 (char *) "winid",(char *) "show", NULL
19991 };
19992
19993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19994 if (obj0) {
19995 {
19996 arg1 = (int)(SWIG_As_int(obj0));
19997 if (SWIG_arg_fail(1)) SWIG_fail;
19998 }
19999 }
20000 if (obj1) {
20001 {
20002 arg2 = (bool)(SWIG_As_bool(obj1));
20003 if (SWIG_arg_fail(2)) SWIG_fail;
20004 }
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj;
20022 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20023 bool arg2 ;
20024 PyObject * obj0 = 0 ;
20025 PyObject * obj1 = 0 ;
20026 char *kwnames[] = {
20027 (char *) "self",(char *) "show", NULL
20028 };
20029
20030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20032 if (SWIG_arg_fail(1)) SWIG_fail;
20033 {
20034 arg2 = (bool)(SWIG_As_bool(obj1));
20035 if (SWIG_arg_fail(2)) SWIG_fail;
20036 }
20037 {
20038 PyThreadState* __tstate = wxPyBeginAllowThreads();
20039 (arg1)->SetShow(arg2);
20040
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 Py_INCREF(Py_None); resultobj = Py_None;
20045 return resultobj;
20046 fail:
20047 return NULL;
20048 }
20049
20050
20051 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20052 PyObject *resultobj;
20053 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20054 bool result;
20055 PyObject * obj0 = 0 ;
20056 char *kwnames[] = {
20057 (char *) "self", NULL
20058 };
20059
20060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20062 if (SWIG_arg_fail(1)) SWIG_fail;
20063 {
20064 PyThreadState* __tstate = wxPyBeginAllowThreads();
20065 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20066
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 {
20071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20072 }
20073 return resultobj;
20074 fail:
20075 return NULL;
20076 }
20077
20078
20079 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20080 PyObject *obj;
20081 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20082 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20083 Py_INCREF(obj);
20084 return Py_BuildValue((char *)"");
20085 }
20086 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20087 PyObject *resultobj;
20088 int arg1 = (int) 0 ;
20089 bool arg2 = (bool) true ;
20090 wxIconizeEvent *result;
20091 PyObject * obj0 = 0 ;
20092 PyObject * obj1 = 0 ;
20093 char *kwnames[] = {
20094 (char *) "id",(char *) "iconized", NULL
20095 };
20096
20097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20098 if (obj0) {
20099 {
20100 arg1 = (int)(SWIG_As_int(obj0));
20101 if (SWIG_arg_fail(1)) SWIG_fail;
20102 }
20103 }
20104 if (obj1) {
20105 {
20106 arg2 = (bool)(SWIG_As_bool(obj1));
20107 if (SWIG_arg_fail(2)) SWIG_fail;
20108 }
20109 }
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20113
20114 wxPyEndAllowThreads(__tstate);
20115 if (PyErr_Occurred()) SWIG_fail;
20116 }
20117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20118 return resultobj;
20119 fail:
20120 return NULL;
20121 }
20122
20123
20124 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj;
20126 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20127 bool result;
20128 PyObject * obj0 = 0 ;
20129 char *kwnames[] = {
20130 (char *) "self", NULL
20131 };
20132
20133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20135 if (SWIG_arg_fail(1)) SWIG_fail;
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 result = (bool)(arg1)->Iconized();
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20145 }
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20153 PyObject *obj;
20154 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20155 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20156 Py_INCREF(obj);
20157 return Py_BuildValue((char *)"");
20158 }
20159 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20160 PyObject *resultobj;
20161 int arg1 = (int) 0 ;
20162 wxMaximizeEvent *result;
20163 PyObject * obj0 = 0 ;
20164 char *kwnames[] = {
20165 (char *) "id", NULL
20166 };
20167
20168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20169 if (obj0) {
20170 {
20171 arg1 = (int)(SWIG_As_int(obj0));
20172 if (SWIG_arg_fail(1)) SWIG_fail;
20173 }
20174 }
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20178
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20190 PyObject *obj;
20191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20192 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20193 Py_INCREF(obj);
20194 return Py_BuildValue((char *)"");
20195 }
20196 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj;
20198 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20199 wxPoint result;
20200 PyObject * obj0 = 0 ;
20201 char *kwnames[] = {
20202 (char *) "self", NULL
20203 };
20204
20205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20207 if (SWIG_arg_fail(1)) SWIG_fail;
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = (arg1)->GetPosition();
20211
20212 wxPyEndAllowThreads(__tstate);
20213 if (PyErr_Occurred()) SWIG_fail;
20214 }
20215 {
20216 wxPoint * resultptr;
20217 resultptr = new wxPoint((wxPoint &)(result));
20218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20219 }
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20227 PyObject *resultobj;
20228 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20229 int result;
20230 PyObject * obj0 = 0 ;
20231 char *kwnames[] = {
20232 (char *) "self", NULL
20233 };
20234
20235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20237 if (SWIG_arg_fail(1)) SWIG_fail;
20238 {
20239 PyThreadState* __tstate = wxPyBeginAllowThreads();
20240 result = (int)(arg1)->GetNumberOfFiles();
20241
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 {
20246 resultobj = SWIG_From_int((int)(result));
20247 }
20248 return resultobj;
20249 fail:
20250 return NULL;
20251 }
20252
20253
20254 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20257 PyObject *result;
20258 PyObject * obj0 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20269
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 resultobj = result;
20274 return resultobj;
20275 fail:
20276 return NULL;
20277 }
20278
20279
20280 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20281 PyObject *obj;
20282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20283 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20284 Py_INCREF(obj);
20285 return Py_BuildValue((char *)"");
20286 }
20287 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj;
20289 int arg1 = (int) 0 ;
20290 wxUpdateUIEvent *result;
20291 PyObject * obj0 = 0 ;
20292 char *kwnames[] = {
20293 (char *) "commandId", NULL
20294 };
20295
20296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20297 if (obj0) {
20298 {
20299 arg1 = (int)(SWIG_As_int(obj0));
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 }
20302 }
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20306
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20318 PyObject *resultobj;
20319 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20320 bool result;
20321 PyObject * obj0 = 0 ;
20322 char *kwnames[] = {
20323 (char *) "self", NULL
20324 };
20325
20326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20328 if (SWIG_arg_fail(1)) SWIG_fail;
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20332
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 {
20337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20338 }
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20348 bool result;
20349 PyObject * obj0 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "self", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20356 if (SWIG_arg_fail(1)) SWIG_fail;
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20360
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20374 PyObject *resultobj;
20375 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20376 wxString result;
20377 PyObject * obj0 = 0 ;
20378 char *kwnames[] = {
20379 (char *) "self", NULL
20380 };
20381
20382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20384 if (SWIG_arg_fail(1)) SWIG_fail;
20385 {
20386 PyThreadState* __tstate = wxPyBeginAllowThreads();
20387 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20388
20389 wxPyEndAllowThreads(__tstate);
20390 if (PyErr_Occurred()) SWIG_fail;
20391 }
20392 {
20393 #if wxUSE_UNICODE
20394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20395 #else
20396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20397 #endif
20398 }
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20406 PyObject *resultobj;
20407 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20408 bool result;
20409 PyObject * obj0 = 0 ;
20410 char *kwnames[] = {
20411 (char *) "self", NULL
20412 };
20413
20414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20416 if (SWIG_arg_fail(1)) SWIG_fail;
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20420
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 {
20425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20426 }
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20434 PyObject *resultobj;
20435 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20436 bool result;
20437 PyObject * obj0 = 0 ;
20438 char *kwnames[] = {
20439 (char *) "self", NULL
20440 };
20441
20442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20444 if (SWIG_arg_fail(1)) SWIG_fail;
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20448
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 {
20453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20454 }
20455 return resultobj;
20456 fail:
20457 return NULL;
20458 }
20459
20460
20461 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20462 PyObject *resultobj;
20463 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20464 bool result;
20465 PyObject * obj0 = 0 ;
20466 char *kwnames[] = {
20467 (char *) "self", NULL
20468 };
20469
20470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20472 if (SWIG_arg_fail(1)) SWIG_fail;
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20476
20477 wxPyEndAllowThreads(__tstate);
20478 if (PyErr_Occurred()) SWIG_fail;
20479 }
20480 {
20481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20482 }
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj;
20491 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20492 bool arg2 ;
20493 PyObject * obj0 = 0 ;
20494 PyObject * obj1 = 0 ;
20495 char *kwnames[] = {
20496 (char *) "self",(char *) "check", NULL
20497 };
20498
20499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20501 if (SWIG_arg_fail(1)) SWIG_fail;
20502 {
20503 arg2 = (bool)(SWIG_As_bool(obj1));
20504 if (SWIG_arg_fail(2)) SWIG_fail;
20505 }
20506 {
20507 PyThreadState* __tstate = wxPyBeginAllowThreads();
20508 (arg1)->Check(arg2);
20509
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 Py_INCREF(Py_None); resultobj = Py_None;
20514 return resultobj;
20515 fail:
20516 return NULL;
20517 }
20518
20519
20520 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20521 PyObject *resultobj;
20522 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20523 bool arg2 ;
20524 PyObject * obj0 = 0 ;
20525 PyObject * obj1 = 0 ;
20526 char *kwnames[] = {
20527 (char *) "self",(char *) "enable", NULL
20528 };
20529
20530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20532 if (SWIG_arg_fail(1)) SWIG_fail;
20533 {
20534 arg2 = (bool)(SWIG_As_bool(obj1));
20535 if (SWIG_arg_fail(2)) SWIG_fail;
20536 }
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 (arg1)->Enable(arg2);
20540
20541 wxPyEndAllowThreads(__tstate);
20542 if (PyErr_Occurred()) SWIG_fail;
20543 }
20544 Py_INCREF(Py_None); resultobj = Py_None;
20545 return resultobj;
20546 fail:
20547 return NULL;
20548 }
20549
20550
20551 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20552 PyObject *resultobj;
20553 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20554 wxString *arg2 = 0 ;
20555 bool temp2 = false ;
20556 PyObject * obj0 = 0 ;
20557 PyObject * obj1 = 0 ;
20558 char *kwnames[] = {
20559 (char *) "self",(char *) "text", NULL
20560 };
20561
20562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20564 if (SWIG_arg_fail(1)) SWIG_fail;
20565 {
20566 arg2 = wxString_in_helper(obj1);
20567 if (arg2 == NULL) SWIG_fail;
20568 temp2 = true;
20569 }
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 (arg1)->SetText((wxString const &)*arg2);
20573
20574 wxPyEndAllowThreads(__tstate);
20575 if (PyErr_Occurred()) SWIG_fail;
20576 }
20577 Py_INCREF(Py_None); resultobj = Py_None;
20578 {
20579 if (temp2)
20580 delete arg2;
20581 }
20582 return resultobj;
20583 fail:
20584 {
20585 if (temp2)
20586 delete arg2;
20587 }
20588 return NULL;
20589 }
20590
20591
20592 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20593 PyObject *resultobj;
20594 long arg1 ;
20595 PyObject * obj0 = 0 ;
20596 char *kwnames[] = {
20597 (char *) "updateInterval", NULL
20598 };
20599
20600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20601 {
20602 arg1 = (long)(SWIG_As_long(obj0));
20603 if (SWIG_arg_fail(1)) SWIG_fail;
20604 }
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 wxUpdateUIEvent::SetUpdateInterval(arg1);
20608
20609 wxPyEndAllowThreads(__tstate);
20610 if (PyErr_Occurred()) SWIG_fail;
20611 }
20612 Py_INCREF(Py_None); resultobj = Py_None;
20613 return resultobj;
20614 fail:
20615 return NULL;
20616 }
20617
20618
20619 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj;
20621 long result;
20622 char *kwnames[] = {
20623 NULL
20624 };
20625
20626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20630
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 {
20635 resultobj = SWIG_From_long((long)(result));
20636 }
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20644 PyObject *resultobj;
20645 wxWindow *arg1 = (wxWindow *) 0 ;
20646 bool result;
20647 PyObject * obj0 = 0 ;
20648 char *kwnames[] = {
20649 (char *) "win", NULL
20650 };
20651
20652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20654 if (SWIG_arg_fail(1)) SWIG_fail;
20655 {
20656 PyThreadState* __tstate = wxPyBeginAllowThreads();
20657 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20658
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj;
20673 char *kwnames[] = {
20674 NULL
20675 };
20676
20677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 wxUpdateUIEvent::ResetUpdateTime();
20681
20682 wxPyEndAllowThreads(__tstate);
20683 if (PyErr_Occurred()) SWIG_fail;
20684 }
20685 Py_INCREF(Py_None); resultobj = Py_None;
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20693 PyObject *resultobj;
20694 wxUpdateUIMode arg1 ;
20695 PyObject * obj0 = 0 ;
20696 char *kwnames[] = {
20697 (char *) "mode", NULL
20698 };
20699
20700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20701 {
20702 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20703 if (SWIG_arg_fail(1)) SWIG_fail;
20704 }
20705 {
20706 PyThreadState* __tstate = wxPyBeginAllowThreads();
20707 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20708
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 Py_INCREF(Py_None); resultobj = Py_None;
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj;
20721 wxUpdateUIMode result;
20722 char *kwnames[] = {
20723 NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20730
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 resultobj = SWIG_From_int((result));
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20742 PyObject *obj;
20743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20744 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20745 Py_INCREF(obj);
20746 return Py_BuildValue((char *)"");
20747 }
20748 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20749 PyObject *resultobj;
20750 wxSysColourChangedEvent *result;
20751 char *kwnames[] = {
20752 NULL
20753 };
20754
20755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20759
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20771 PyObject *obj;
20772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20773 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20774 Py_INCREF(obj);
20775 return Py_BuildValue((char *)"");
20776 }
20777 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20778 PyObject *resultobj;
20779 int arg1 = (int) 0 ;
20780 wxWindow *arg2 = (wxWindow *) NULL ;
20781 wxMouseCaptureChangedEvent *result;
20782 PyObject * obj0 = 0 ;
20783 PyObject * obj1 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "winid",(char *) "gainedCapture", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 if (obj1) {
20796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20797 if (SWIG_arg_fail(2)) SWIG_fail;
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj;
20815 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20816 wxWindow *result;
20817 PyObject * obj0 = 0 ;
20818 char *kwnames[] = {
20819 (char *) "self", NULL
20820 };
20821
20822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20824 if (SWIG_arg_fail(1)) SWIG_fail;
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20828
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = wxPyMake_wxObject(result, 0);
20834 }
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20842 PyObject *obj;
20843 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20844 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20845 Py_INCREF(obj);
20846 return Py_BuildValue((char *)"");
20847 }
20848 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj;
20850 wxDisplayChangedEvent *result;
20851 char *kwnames[] = {
20852 NULL
20853 };
20854
20855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20856 {
20857 PyThreadState* __tstate = wxPyBeginAllowThreads();
20858 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20859
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20871 PyObject *obj;
20872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20873 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20874 Py_INCREF(obj);
20875 return Py_BuildValue((char *)"");
20876 }
20877 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 int arg1 = (int) 0 ;
20880 wxPaletteChangedEvent *result;
20881 PyObject * obj0 = 0 ;
20882 char *kwnames[] = {
20883 (char *) "id", NULL
20884 };
20885
20886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20887 if (obj0) {
20888 {
20889 arg1 = (int)(SWIG_As_int(obj0));
20890 if (SWIG_arg_fail(1)) SWIG_fail;
20891 }
20892 }
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20896
20897 wxPyEndAllowThreads(__tstate);
20898 if (PyErr_Occurred()) SWIG_fail;
20899 }
20900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20901 return resultobj;
20902 fail:
20903 return NULL;
20904 }
20905
20906
20907 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20908 PyObject *resultobj;
20909 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20910 wxWindow *arg2 = (wxWindow *) 0 ;
20911 PyObject * obj0 = 0 ;
20912 PyObject * obj1 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self",(char *) "win", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20921 if (SWIG_arg_fail(2)) SWIG_fail;
20922 {
20923 PyThreadState* __tstate = wxPyBeginAllowThreads();
20924 (arg1)->SetChangedWindow(arg2);
20925
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 Py_INCREF(Py_None); resultobj = Py_None;
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20937 PyObject *resultobj;
20938 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20939 wxWindow *result;
20940 PyObject * obj0 = 0 ;
20941 char *kwnames[] = {
20942 (char *) "self", NULL
20943 };
20944
20945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20947 if (SWIG_arg_fail(1)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (wxWindow *)(arg1)->GetChangedWindow();
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = wxPyMake_wxObject(result, 0);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20965 PyObject *obj;
20966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20967 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20968 Py_INCREF(obj);
20969 return Py_BuildValue((char *)"");
20970 }
20971 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20972 PyObject *resultobj;
20973 int arg1 = (int) 0 ;
20974 wxQueryNewPaletteEvent *result;
20975 PyObject * obj0 = 0 ;
20976 char *kwnames[] = {
20977 (char *) "winid", NULL
20978 };
20979
20980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20981 if (obj0) {
20982 {
20983 arg1 = (int)(SWIG_As_int(obj0));
20984 if (SWIG_arg_fail(1)) SWIG_fail;
20985 }
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21004 bool arg2 ;
21005 PyObject * obj0 = 0 ;
21006 PyObject * obj1 = 0 ;
21007 char *kwnames[] = {
21008 (char *) "self",(char *) "realized", NULL
21009 };
21010
21011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21013 if (SWIG_arg_fail(1)) SWIG_fail;
21014 {
21015 arg2 = (bool)(SWIG_As_bool(obj1));
21016 if (SWIG_arg_fail(2)) SWIG_fail;
21017 }
21018 {
21019 PyThreadState* __tstate = wxPyBeginAllowThreads();
21020 (arg1)->SetPaletteRealized(arg2);
21021
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 Py_INCREF(Py_None); resultobj = Py_None;
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21033 PyObject *resultobj;
21034 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21035 bool result;
21036 PyObject * obj0 = 0 ;
21037 char *kwnames[] = {
21038 (char *) "self", NULL
21039 };
21040
21041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21043 if (SWIG_arg_fail(1)) SWIG_fail;
21044 {
21045 PyThreadState* __tstate = wxPyBeginAllowThreads();
21046 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21047
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 {
21052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21061 PyObject *obj;
21062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21063 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21064 Py_INCREF(obj);
21065 return Py_BuildValue((char *)"");
21066 }
21067 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21068 PyObject *resultobj;
21069 wxNavigationKeyEvent *result;
21070 char *kwnames[] = {
21071 NULL
21072 };
21073
21074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21078
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj;
21091 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21092 bool result;
21093 PyObject * obj0 = 0 ;
21094 char *kwnames[] = {
21095 (char *) "self", NULL
21096 };
21097
21098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21100 if (SWIG_arg_fail(1)) SWIG_fail;
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21104
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 {
21109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21110 }
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21118 PyObject *resultobj;
21119 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21120 bool arg2 ;
21121 PyObject * obj0 = 0 ;
21122 PyObject * obj1 = 0 ;
21123 char *kwnames[] = {
21124 (char *) "self",(char *) "forward", NULL
21125 };
21126
21127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21129 if (SWIG_arg_fail(1)) SWIG_fail;
21130 {
21131 arg2 = (bool)(SWIG_As_bool(obj1));
21132 if (SWIG_arg_fail(2)) SWIG_fail;
21133 }
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->SetDirection(arg2);
21137
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 Py_INCREF(Py_None); resultobj = Py_None;
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21149 PyObject *resultobj;
21150 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21151 bool result;
21152 PyObject * obj0 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "self", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj;
21178 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21179 bool arg2 ;
21180 PyObject * obj0 = 0 ;
21181 PyObject * obj1 = 0 ;
21182 char *kwnames[] = {
21183 (char *) "self",(char *) "ischange", NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21188 if (SWIG_arg_fail(1)) SWIG_fail;
21189 {
21190 arg2 = (bool)(SWIG_As_bool(obj1));
21191 if (SWIG_arg_fail(2)) SWIG_fail;
21192 }
21193 {
21194 PyThreadState* __tstate = wxPyBeginAllowThreads();
21195 (arg1)->SetWindowChange(arg2);
21196
21197 wxPyEndAllowThreads(__tstate);
21198 if (PyErr_Occurred()) SWIG_fail;
21199 }
21200 Py_INCREF(Py_None); resultobj = Py_None;
21201 return resultobj;
21202 fail:
21203 return NULL;
21204 }
21205
21206
21207 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21208 PyObject *resultobj;
21209 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21210 bool result;
21211 PyObject * obj0 = 0 ;
21212 char *kwnames[] = {
21213 (char *) "self", NULL
21214 };
21215
21216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21218 if (SWIG_arg_fail(1)) SWIG_fail;
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21222
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 {
21227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21228 }
21229 return resultobj;
21230 fail:
21231 return NULL;
21232 }
21233
21234
21235 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21236 PyObject *resultobj;
21237 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21238 bool arg2 ;
21239 PyObject * obj0 = 0 ;
21240 PyObject * obj1 = 0 ;
21241 char *kwnames[] = {
21242 (char *) "self",(char *) "bIs", NULL
21243 };
21244
21245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21247 if (SWIG_arg_fail(1)) SWIG_fail;
21248 {
21249 arg2 = (bool)(SWIG_As_bool(obj1));
21250 if (SWIG_arg_fail(2)) SWIG_fail;
21251 }
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 (arg1)->SetFromTab(arg2);
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 Py_INCREF(Py_None); resultobj = Py_None;
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21267 PyObject *resultobj;
21268 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21269 long arg2 ;
21270 PyObject * obj0 = 0 ;
21271 PyObject * obj1 = 0 ;
21272 char *kwnames[] = {
21273 (char *) "self",(char *) "flags", NULL
21274 };
21275
21276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21278 if (SWIG_arg_fail(1)) SWIG_fail;
21279 {
21280 arg2 = (long)(SWIG_As_long(obj1));
21281 if (SWIG_arg_fail(2)) SWIG_fail;
21282 }
21283 {
21284 PyThreadState* __tstate = wxPyBeginAllowThreads();
21285 (arg1)->SetFlags(arg2);
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 Py_INCREF(Py_None); resultobj = Py_None;
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj;
21299 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21300 wxWindow *result;
21301 PyObject * obj0 = 0 ;
21302 char *kwnames[] = {
21303 (char *) "self", NULL
21304 };
21305
21306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21312
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = wxPyMake_wxObject(result, 0);
21318 }
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21326 PyObject *resultobj;
21327 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21328 wxWindow *arg2 = (wxWindow *) 0 ;
21329 PyObject * obj0 = 0 ;
21330 PyObject * obj1 = 0 ;
21331 char *kwnames[] = {
21332 (char *) "self",(char *) "win", NULL
21333 };
21334
21335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21337 if (SWIG_arg_fail(1)) SWIG_fail;
21338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21339 if (SWIG_arg_fail(2)) SWIG_fail;
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 (arg1)->SetCurrentFocus(arg2);
21343
21344 wxPyEndAllowThreads(__tstate);
21345 if (PyErr_Occurred()) SWIG_fail;
21346 }
21347 Py_INCREF(Py_None); resultobj = Py_None;
21348 return resultobj;
21349 fail:
21350 return NULL;
21351 }
21352
21353
21354 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21355 PyObject *obj;
21356 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21357 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21358 Py_INCREF(obj);
21359 return Py_BuildValue((char *)"");
21360 }
21361 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21362 PyObject *resultobj;
21363 wxWindow *arg1 = (wxWindow *) NULL ;
21364 wxWindowCreateEvent *result;
21365 PyObject * obj0 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "win", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21371 if (obj0) {
21372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21373 if (SWIG_arg_fail(1)) SWIG_fail;
21374 }
21375 {
21376 PyThreadState* __tstate = wxPyBeginAllowThreads();
21377 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21378
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj;
21391 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21392 wxWindow *result;
21393 PyObject * obj0 = 0 ;
21394 char *kwnames[] = {
21395 (char *) "self", NULL
21396 };
21397
21398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21400 if (SWIG_arg_fail(1)) SWIG_fail;
21401 {
21402 PyThreadState* __tstate = wxPyBeginAllowThreads();
21403 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21404
21405 wxPyEndAllowThreads(__tstate);
21406 if (PyErr_Occurred()) SWIG_fail;
21407 }
21408 {
21409 resultobj = wxPyMake_wxObject(result, 0);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21418 PyObject *obj;
21419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21420 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21421 Py_INCREF(obj);
21422 return Py_BuildValue((char *)"");
21423 }
21424 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21425 PyObject *resultobj;
21426 wxWindow *arg1 = (wxWindow *) NULL ;
21427 wxWindowDestroyEvent *result;
21428 PyObject * obj0 = 0 ;
21429 char *kwnames[] = {
21430 (char *) "win", NULL
21431 };
21432
21433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21434 if (obj0) {
21435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21436 if (SWIG_arg_fail(1)) SWIG_fail;
21437 }
21438 {
21439 PyThreadState* __tstate = wxPyBeginAllowThreads();
21440 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21441
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21453 PyObject *resultobj;
21454 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21455 wxWindow *result;
21456 PyObject * obj0 = 0 ;
21457 char *kwnames[] = {
21458 (char *) "self", NULL
21459 };
21460
21461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21463 if (SWIG_arg_fail(1)) SWIG_fail;
21464 {
21465 PyThreadState* __tstate = wxPyBeginAllowThreads();
21466 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21467
21468 wxPyEndAllowThreads(__tstate);
21469 if (PyErr_Occurred()) SWIG_fail;
21470 }
21471 {
21472 resultobj = wxPyMake_wxObject(result, 0);
21473 }
21474 return resultobj;
21475 fail:
21476 return NULL;
21477 }
21478
21479
21480 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21481 PyObject *obj;
21482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21483 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21484 Py_INCREF(obj);
21485 return Py_BuildValue((char *)"");
21486 }
21487 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21488 PyObject *resultobj;
21489 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21490 int arg2 = (int) 0 ;
21491 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21492 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21493 wxContextMenuEvent *result;
21494 wxPoint temp3 ;
21495 PyObject * obj0 = 0 ;
21496 PyObject * obj1 = 0 ;
21497 PyObject * obj2 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "type",(char *) "winid",(char *) "pt", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21503 if (obj0) {
21504 {
21505 arg1 = (wxEventType)(SWIG_As_int(obj0));
21506 if (SWIG_arg_fail(1)) SWIG_fail;
21507 }
21508 }
21509 if (obj1) {
21510 {
21511 arg2 = (int)(SWIG_As_int(obj1));
21512 if (SWIG_arg_fail(2)) SWIG_fail;
21513 }
21514 }
21515 if (obj2) {
21516 {
21517 arg3 = &temp3;
21518 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21519 }
21520 }
21521 {
21522 PyThreadState* __tstate = wxPyBeginAllowThreads();
21523 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21524
21525 wxPyEndAllowThreads(__tstate);
21526 if (PyErr_Occurred()) SWIG_fail;
21527 }
21528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21536 PyObject *resultobj;
21537 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21538 wxPoint *result;
21539 PyObject * obj0 = 0 ;
21540 char *kwnames[] = {
21541 (char *) "self", NULL
21542 };
21543
21544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21546 if (SWIG_arg_fail(1)) SWIG_fail;
21547 {
21548 PyThreadState* __tstate = wxPyBeginAllowThreads();
21549 {
21550 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21551 result = (wxPoint *) &_result_ref;
21552 }
21553
21554 wxPyEndAllowThreads(__tstate);
21555 if (PyErr_Occurred()) SWIG_fail;
21556 }
21557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj;
21566 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21567 wxPoint *arg2 = 0 ;
21568 wxPoint temp2 ;
21569 PyObject * obj0 = 0 ;
21570 PyObject * obj1 = 0 ;
21571 char *kwnames[] = {
21572 (char *) "self",(char *) "pos", NULL
21573 };
21574
21575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21577 if (SWIG_arg_fail(1)) SWIG_fail;
21578 {
21579 arg2 = &temp2;
21580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21581 }
21582 {
21583 PyThreadState* __tstate = wxPyBeginAllowThreads();
21584 (arg1)->SetPosition((wxPoint const &)*arg2);
21585
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 Py_INCREF(Py_None); resultobj = Py_None;
21590 return resultobj;
21591 fail:
21592 return NULL;
21593 }
21594
21595
21596 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21597 PyObject *obj;
21598 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21599 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21600 Py_INCREF(obj);
21601 return Py_BuildValue((char *)"");
21602 }
21603 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21604 PyObject *resultobj;
21605 wxIdleEvent *result;
21606 char *kwnames[] = {
21607 NULL
21608 };
21609
21610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21611 {
21612 PyThreadState* __tstate = wxPyBeginAllowThreads();
21613 result = (wxIdleEvent *)new wxIdleEvent();
21614
21615 wxPyEndAllowThreads(__tstate);
21616 if (PyErr_Occurred()) SWIG_fail;
21617 }
21618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj;
21627 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21628 bool arg2 = (bool) true ;
21629 PyObject * obj0 = 0 ;
21630 PyObject * obj1 = 0 ;
21631 char *kwnames[] = {
21632 (char *) "self",(char *) "needMore", NULL
21633 };
21634
21635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21637 if (SWIG_arg_fail(1)) SWIG_fail;
21638 if (obj1) {
21639 {
21640 arg2 = (bool)(SWIG_As_bool(obj1));
21641 if (SWIG_arg_fail(2)) SWIG_fail;
21642 }
21643 }
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 (arg1)->RequestMore(arg2);
21647
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 Py_INCREF(Py_None); resultobj = Py_None;
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21659 PyObject *resultobj;
21660 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21661 bool result;
21662 PyObject * obj0 = 0 ;
21663 char *kwnames[] = {
21664 (char *) "self", NULL
21665 };
21666
21667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21669 if (SWIG_arg_fail(1)) SWIG_fail;
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21673
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 {
21678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21679 }
21680 return resultobj;
21681 fail:
21682 return NULL;
21683 }
21684
21685
21686 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21687 PyObject *resultobj;
21688 wxIdleMode arg1 ;
21689 PyObject * obj0 = 0 ;
21690 char *kwnames[] = {
21691 (char *) "mode", NULL
21692 };
21693
21694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21695 {
21696 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21697 if (SWIG_arg_fail(1)) SWIG_fail;
21698 }
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 wxIdleEvent::SetMode((wxIdleMode )arg1);
21702
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 Py_INCREF(Py_None); resultobj = Py_None;
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21714 PyObject *resultobj;
21715 wxIdleMode result;
21716 char *kwnames[] = {
21717 NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 result = (wxIdleMode)wxIdleEvent::GetMode();
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 resultobj = SWIG_From_int((result));
21729 return resultobj;
21730 fail:
21731 return NULL;
21732 }
21733
21734
21735 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj;
21737 wxWindow *arg1 = (wxWindow *) 0 ;
21738 bool result;
21739 PyObject * obj0 = 0 ;
21740 char *kwnames[] = {
21741 (char *) "win", NULL
21742 };
21743
21744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21746 if (SWIG_arg_fail(1)) SWIG_fail;
21747 {
21748 PyThreadState* __tstate = wxPyBeginAllowThreads();
21749 result = (bool)wxIdleEvent::CanSend(arg1);
21750
21751 wxPyEndAllowThreads(__tstate);
21752 if (PyErr_Occurred()) SWIG_fail;
21753 }
21754 {
21755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21756 }
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21764 PyObject *obj;
21765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21766 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21767 Py_INCREF(obj);
21768 return Py_BuildValue((char *)"");
21769 }
21770 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21771 PyObject *resultobj;
21772 int arg1 = (int) 0 ;
21773 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21774 wxPyEvent *result;
21775 PyObject * obj0 = 0 ;
21776 PyObject * obj1 = 0 ;
21777 char *kwnames[] = {
21778 (char *) "winid",(char *) "commandType", NULL
21779 };
21780
21781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21782 if (obj0) {
21783 {
21784 arg1 = (int)(SWIG_As_int(obj0));
21785 if (SWIG_arg_fail(1)) SWIG_fail;
21786 }
21787 }
21788 if (obj1) {
21789 {
21790 arg2 = (wxEventType)(SWIG_As_int(obj1));
21791 if (SWIG_arg_fail(2)) SWIG_fail;
21792 }
21793 }
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21797
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21809 PyObject *resultobj;
21810 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21811 PyObject * obj0 = 0 ;
21812 char *kwnames[] = {
21813 (char *) "self", NULL
21814 };
21815
21816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21818 if (SWIG_arg_fail(1)) SWIG_fail;
21819 {
21820 PyThreadState* __tstate = wxPyBeginAllowThreads();
21821 delete arg1;
21822
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 Py_INCREF(Py_None); resultobj = Py_None;
21827 return resultobj;
21828 fail:
21829 return NULL;
21830 }
21831
21832
21833 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21834 PyObject *resultobj;
21835 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21836 PyObject *arg2 = (PyObject *) 0 ;
21837 PyObject * obj0 = 0 ;
21838 PyObject * obj1 = 0 ;
21839 char *kwnames[] = {
21840 (char *) "self",(char *) "self", NULL
21841 };
21842
21843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21845 if (SWIG_arg_fail(1)) SWIG_fail;
21846 arg2 = obj1;
21847 {
21848 PyThreadState* __tstate = wxPyBeginAllowThreads();
21849 (arg1)->SetSelf(arg2);
21850
21851 wxPyEndAllowThreads(__tstate);
21852 if (PyErr_Occurred()) SWIG_fail;
21853 }
21854 Py_INCREF(Py_None); resultobj = Py_None;
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21864 PyObject *result;
21865 PyObject * obj0 = 0 ;
21866 char *kwnames[] = {
21867 (char *) "self", NULL
21868 };
21869
21870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21872 if (SWIG_arg_fail(1)) SWIG_fail;
21873 {
21874 PyThreadState* __tstate = wxPyBeginAllowThreads();
21875 result = (PyObject *)(arg1)->GetSelf();
21876
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 resultobj = result;
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21888 PyObject *obj;
21889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21890 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21891 Py_INCREF(obj);
21892 return Py_BuildValue((char *)"");
21893 }
21894 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj;
21896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21897 int arg2 = (int) 0 ;
21898 wxPyCommandEvent *result;
21899 PyObject * obj0 = 0 ;
21900 PyObject * obj1 = 0 ;
21901 char *kwnames[] = {
21902 (char *) "commandType",(char *) "id", NULL
21903 };
21904
21905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21906 if (obj0) {
21907 {
21908 arg1 = (wxEventType)(SWIG_As_int(obj0));
21909 if (SWIG_arg_fail(1)) SWIG_fail;
21910 }
21911 }
21912 if (obj1) {
21913 {
21914 arg2 = (int)(SWIG_As_int(obj1));
21915 if (SWIG_arg_fail(2)) SWIG_fail;
21916 }
21917 }
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21921
21922 wxPyEndAllowThreads(__tstate);
21923 if (PyErr_Occurred()) SWIG_fail;
21924 }
21925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21933 PyObject *resultobj;
21934 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21935 PyObject * obj0 = 0 ;
21936 char *kwnames[] = {
21937 (char *) "self", NULL
21938 };
21939
21940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(1)) SWIG_fail;
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 delete arg1;
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 Py_INCREF(Py_None); resultobj = Py_None;
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj;
21959 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21960 PyObject *arg2 = (PyObject *) 0 ;
21961 PyObject * obj0 = 0 ;
21962 PyObject * obj1 = 0 ;
21963 char *kwnames[] = {
21964 (char *) "self",(char *) "self", NULL
21965 };
21966
21967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21969 if (SWIG_arg_fail(1)) SWIG_fail;
21970 arg2 = obj1;
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 (arg1)->SetSelf(arg2);
21974
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 Py_INCREF(Py_None); resultobj = Py_None;
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21986 PyObject *resultobj;
21987 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21988 PyObject *result;
21989 PyObject * obj0 = 0 ;
21990 char *kwnames[] = {
21991 (char *) "self", NULL
21992 };
21993
21994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21996 if (SWIG_arg_fail(1)) SWIG_fail;
21997 {
21998 PyThreadState* __tstate = wxPyBeginAllowThreads();
21999 result = (PyObject *)(arg1)->GetSelf();
22000
22001 wxPyEndAllowThreads(__tstate);
22002 if (PyErr_Occurred()) SWIG_fail;
22003 }
22004 resultobj = result;
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22012 PyObject *obj;
22013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22014 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22015 Py_INCREF(obj);
22016 return Py_BuildValue((char *)"");
22017 }
22018 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj;
22020 wxWindow *arg1 = (wxWindow *) 0 ;
22021 wxDateTime *arg2 = 0 ;
22022 wxEventType arg3 ;
22023 wxDateEvent *result;
22024 PyObject * obj0 = 0 ;
22025 PyObject * obj1 = 0 ;
22026 PyObject * obj2 = 0 ;
22027 char *kwnames[] = {
22028 (char *) "win",(char *) "dt",(char *) "type", NULL
22029 };
22030
22031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22033 if (SWIG_arg_fail(1)) SWIG_fail;
22034 {
22035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22036 if (SWIG_arg_fail(2)) SWIG_fail;
22037 if (arg2 == NULL) {
22038 SWIG_null_ref("wxDateTime");
22039 }
22040 if (SWIG_arg_fail(2)) SWIG_fail;
22041 }
22042 {
22043 arg3 = (wxEventType)(SWIG_As_int(obj2));
22044 if (SWIG_arg_fail(3)) SWIG_fail;
22045 }
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22049
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22054 return resultobj;
22055 fail:
22056 return NULL;
22057 }
22058
22059
22060 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22063 wxDateTime *result;
22064 PyObject * obj0 = 0 ;
22065 char *kwnames[] = {
22066 (char *) "self", NULL
22067 };
22068
22069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22071 if (SWIG_arg_fail(1)) SWIG_fail;
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 {
22075 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22076 result = (wxDateTime *) &_result_ref;
22077 }
22078
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22083 return resultobj;
22084 fail:
22085 return NULL;
22086 }
22087
22088
22089 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22090 PyObject *resultobj;
22091 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22092 wxDateTime *arg2 = 0 ;
22093 PyObject * obj0 = 0 ;
22094 PyObject * obj1 = 0 ;
22095 char *kwnames[] = {
22096 (char *) "self",(char *) "date", NULL
22097 };
22098
22099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22101 if (SWIG_arg_fail(1)) SWIG_fail;
22102 {
22103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22104 if (SWIG_arg_fail(2)) SWIG_fail;
22105 if (arg2 == NULL) {
22106 SWIG_null_ref("wxDateTime");
22107 }
22108 if (SWIG_arg_fail(2)) SWIG_fail;
22109 }
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 (arg1)->SetDate((wxDateTime const &)*arg2);
22113
22114 wxPyEndAllowThreads(__tstate);
22115 if (PyErr_Occurred()) SWIG_fail;
22116 }
22117 Py_INCREF(Py_None); resultobj = Py_None;
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22125 PyObject *obj;
22126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22127 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22128 Py_INCREF(obj);
22129 return Py_BuildValue((char *)"");
22130 }
22131 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj;
22133 wxPyApp *result;
22134 char *kwnames[] = {
22135 NULL
22136 };
22137
22138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 result = (wxPyApp *)new_wxPyApp();
22142
22143 wxPyEndAllowThreads(__tstate);
22144 if (PyErr_Occurred()) SWIG_fail;
22145 }
22146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22147 return resultobj;
22148 fail:
22149 return NULL;
22150 }
22151
22152
22153 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22154 PyObject *resultobj;
22155 wxPyApp *arg1 = (wxPyApp *) 0 ;
22156 PyObject * obj0 = 0 ;
22157 char *kwnames[] = {
22158 (char *) "self", NULL
22159 };
22160
22161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22163 if (SWIG_arg_fail(1)) SWIG_fail;
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 delete arg1;
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 Py_INCREF(Py_None); resultobj = Py_None;
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxPyApp *arg1 = (wxPyApp *) 0 ;
22181 PyObject *arg2 = (PyObject *) 0 ;
22182 PyObject *arg3 = (PyObject *) 0 ;
22183 PyObject * obj0 = 0 ;
22184 PyObject * obj1 = 0 ;
22185 PyObject * obj2 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "self",(char *) "self",(char *) "_class", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(1)) SWIG_fail;
22193 arg2 = obj1;
22194 arg3 = obj2;
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 (arg1)->_setCallbackInfo(arg2,arg3);
22198
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 Py_INCREF(Py_None); resultobj = Py_None;
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22210 PyObject *resultobj;
22211 wxPyApp *arg1 = (wxPyApp *) 0 ;
22212 wxString result;
22213 PyObject * obj0 = 0 ;
22214 char *kwnames[] = {
22215 (char *) "self", NULL
22216 };
22217
22218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(1)) SWIG_fail;
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = ((wxPyApp const *)arg1)->GetAppName();
22224
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 {
22229 #if wxUSE_UNICODE
22230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22231 #else
22232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22233 #endif
22234 }
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22242 PyObject *resultobj;
22243 wxPyApp *arg1 = (wxPyApp *) 0 ;
22244 wxString *arg2 = 0 ;
22245 bool temp2 = false ;
22246 PyObject * obj0 = 0 ;
22247 PyObject * obj1 = 0 ;
22248 char *kwnames[] = {
22249 (char *) "self",(char *) "name", NULL
22250 };
22251
22252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22254 if (SWIG_arg_fail(1)) SWIG_fail;
22255 {
22256 arg2 = wxString_in_helper(obj1);
22257 if (arg2 == NULL) SWIG_fail;
22258 temp2 = true;
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 (arg1)->SetAppName((wxString const &)*arg2);
22263
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 Py_INCREF(Py_None); resultobj = Py_None;
22268 {
22269 if (temp2)
22270 delete arg2;
22271 }
22272 return resultobj;
22273 fail:
22274 {
22275 if (temp2)
22276 delete arg2;
22277 }
22278 return NULL;
22279 }
22280
22281
22282 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22283 PyObject *resultobj;
22284 wxPyApp *arg1 = (wxPyApp *) 0 ;
22285 wxString result;
22286 PyObject * obj0 = 0 ;
22287 char *kwnames[] = {
22288 (char *) "self", NULL
22289 };
22290
22291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22293 if (SWIG_arg_fail(1)) SWIG_fail;
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = ((wxPyApp const *)arg1)->GetClassName();
22297
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 {
22302 #if wxUSE_UNICODE
22303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22304 #else
22305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22306 #endif
22307 }
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj;
22316 wxPyApp *arg1 = (wxPyApp *) 0 ;
22317 wxString *arg2 = 0 ;
22318 bool temp2 = false ;
22319 PyObject * obj0 = 0 ;
22320 PyObject * obj1 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self",(char *) "name", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 arg2 = wxString_in_helper(obj1);
22330 if (arg2 == NULL) SWIG_fail;
22331 temp2 = true;
22332 }
22333 {
22334 PyThreadState* __tstate = wxPyBeginAllowThreads();
22335 (arg1)->SetClassName((wxString const &)*arg2);
22336
22337 wxPyEndAllowThreads(__tstate);
22338 if (PyErr_Occurred()) SWIG_fail;
22339 }
22340 Py_INCREF(Py_None); resultobj = Py_None;
22341 {
22342 if (temp2)
22343 delete arg2;
22344 }
22345 return resultobj;
22346 fail:
22347 {
22348 if (temp2)
22349 delete arg2;
22350 }
22351 return NULL;
22352 }
22353
22354
22355 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22356 PyObject *resultobj;
22357 wxPyApp *arg1 = (wxPyApp *) 0 ;
22358 wxString *result;
22359 PyObject * obj0 = 0 ;
22360 char *kwnames[] = {
22361 (char *) "self", NULL
22362 };
22363
22364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(1)) SWIG_fail;
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 {
22370 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22371 result = (wxString *) &_result_ref;
22372 }
22373
22374 wxPyEndAllowThreads(__tstate);
22375 if (PyErr_Occurred()) SWIG_fail;
22376 }
22377 {
22378 #if wxUSE_UNICODE
22379 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22380 #else
22381 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22382 #endif
22383 }
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj;
22392 wxPyApp *arg1 = (wxPyApp *) 0 ;
22393 wxString *arg2 = 0 ;
22394 bool temp2 = false ;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397 char *kwnames[] = {
22398 (char *) "self",(char *) "name", NULL
22399 };
22400
22401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22403 if (SWIG_arg_fail(1)) SWIG_fail;
22404 {
22405 arg2 = wxString_in_helper(obj1);
22406 if (arg2 == NULL) SWIG_fail;
22407 temp2 = true;
22408 }
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 (arg1)->SetVendorName((wxString const &)*arg2);
22412
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 Py_INCREF(Py_None); resultobj = Py_None;
22417 {
22418 if (temp2)
22419 delete arg2;
22420 }
22421 return resultobj;
22422 fail:
22423 {
22424 if (temp2)
22425 delete arg2;
22426 }
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxPyApp *arg1 = (wxPyApp *) 0 ;
22434 wxAppTraits *result;
22435 PyObject * obj0 = 0 ;
22436 char *kwnames[] = {
22437 (char *) "self", NULL
22438 };
22439
22440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(1)) SWIG_fail;
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 result = (wxAppTraits *)(arg1)->GetTraits();
22446
22447 wxPyEndAllowThreads(__tstate);
22448 if (PyErr_Occurred()) SWIG_fail;
22449 }
22450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22458 PyObject *resultobj;
22459 wxPyApp *arg1 = (wxPyApp *) 0 ;
22460 PyObject * obj0 = 0 ;
22461 char *kwnames[] = {
22462 (char *) "self", NULL
22463 };
22464
22465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22467 if (SWIG_arg_fail(1)) SWIG_fail;
22468 {
22469 PyThreadState* __tstate = wxPyBeginAllowThreads();
22470 (arg1)->ProcessPendingEvents();
22471
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 Py_INCREF(Py_None); resultobj = Py_None;
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22483 PyObject *resultobj;
22484 wxPyApp *arg1 = (wxPyApp *) 0 ;
22485 bool arg2 = (bool) false ;
22486 bool result;
22487 PyObject * obj0 = 0 ;
22488 PyObject * obj1 = 0 ;
22489 char *kwnames[] = {
22490 (char *) "self",(char *) "onlyIfNeeded", NULL
22491 };
22492
22493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22495 if (SWIG_arg_fail(1)) SWIG_fail;
22496 if (obj1) {
22497 {
22498 arg2 = (bool)(SWIG_As_bool(obj1));
22499 if (SWIG_arg_fail(2)) SWIG_fail;
22500 }
22501 }
22502 {
22503 PyThreadState* __tstate = wxPyBeginAllowThreads();
22504 result = (bool)(arg1)->Yield(arg2);
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 {
22510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22511 }
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22519 PyObject *resultobj;
22520 wxPyApp *arg1 = (wxPyApp *) 0 ;
22521 PyObject * obj0 = 0 ;
22522 char *kwnames[] = {
22523 (char *) "self", NULL
22524 };
22525
22526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(1)) SWIG_fail;
22529 {
22530 PyThreadState* __tstate = wxPyBeginAllowThreads();
22531 (arg1)->WakeUpIdle();
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 Py_INCREF(Py_None); resultobj = Py_None;
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22544 PyObject *resultobj;
22545 bool result;
22546 char *kwnames[] = {
22547 NULL
22548 };
22549
22550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 result = (bool)wxPyApp::IsMainLoopRunning();
22554
22555 wxPyEndAllowThreads(__tstate);
22556 if (PyErr_Occurred()) SWIG_fail;
22557 }
22558 {
22559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22560 }
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22568 PyObject *resultobj;
22569 wxPyApp *arg1 = (wxPyApp *) 0 ;
22570 int result;
22571 PyObject * obj0 = 0 ;
22572 char *kwnames[] = {
22573 (char *) "self", NULL
22574 };
22575
22576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22578 if (SWIG_arg_fail(1)) SWIG_fail;
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 result = (int)(arg1)->MainLoop();
22582
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 {
22587 resultobj = SWIG_From_int((int)(result));
22588 }
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22596 PyObject *resultobj;
22597 wxPyApp *arg1 = (wxPyApp *) 0 ;
22598 PyObject * obj0 = 0 ;
22599 char *kwnames[] = {
22600 (char *) "self", NULL
22601 };
22602
22603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(1)) SWIG_fail;
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 (arg1)->Exit();
22609
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 Py_INCREF(Py_None); resultobj = Py_None;
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj;
22622 wxPyApp *arg1 = (wxPyApp *) 0 ;
22623 PyObject * obj0 = 0 ;
22624 char *kwnames[] = {
22625 (char *) "self", NULL
22626 };
22627
22628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22630 if (SWIG_arg_fail(1)) SWIG_fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 (arg1)->ExitMainLoop();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 Py_INCREF(Py_None); resultobj = Py_None;
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj;
22647 wxPyApp *arg1 = (wxPyApp *) 0 ;
22648 bool result;
22649 PyObject * obj0 = 0 ;
22650 char *kwnames[] = {
22651 (char *) "self", NULL
22652 };
22653
22654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22656 if (SWIG_arg_fail(1)) SWIG_fail;
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 result = (bool)(arg1)->Pending();
22660
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 {
22665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22666 }
22667 return resultobj;
22668 fail:
22669 return NULL;
22670 }
22671
22672
22673 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22674 PyObject *resultobj;
22675 wxPyApp *arg1 = (wxPyApp *) 0 ;
22676 bool result;
22677 PyObject * obj0 = 0 ;
22678 char *kwnames[] = {
22679 (char *) "self", NULL
22680 };
22681
22682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22684 if (SWIG_arg_fail(1)) SWIG_fail;
22685 {
22686 PyThreadState* __tstate = wxPyBeginAllowThreads();
22687 result = (bool)(arg1)->Dispatch();
22688
22689 wxPyEndAllowThreads(__tstate);
22690 if (PyErr_Occurred()) SWIG_fail;
22691 }
22692 {
22693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22694 }
22695 return resultobj;
22696 fail:
22697 return NULL;
22698 }
22699
22700
22701 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22702 PyObject *resultobj;
22703 wxPyApp *arg1 = (wxPyApp *) 0 ;
22704 bool result;
22705 PyObject * obj0 = 0 ;
22706 char *kwnames[] = {
22707 (char *) "self", NULL
22708 };
22709
22710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22712 if (SWIG_arg_fail(1)) SWIG_fail;
22713 {
22714 PyThreadState* __tstate = wxPyBeginAllowThreads();
22715 result = (bool)(arg1)->ProcessIdle();
22716
22717 wxPyEndAllowThreads(__tstate);
22718 if (PyErr_Occurred()) SWIG_fail;
22719 }
22720 {
22721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22722 }
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22730 PyObject *resultobj;
22731 wxPyApp *arg1 = (wxPyApp *) 0 ;
22732 wxWindow *arg2 = (wxWindow *) 0 ;
22733 wxIdleEvent *arg3 = 0 ;
22734 bool result;
22735 PyObject * obj0 = 0 ;
22736 PyObject * obj1 = 0 ;
22737 PyObject * obj2 = 0 ;
22738 char *kwnames[] = {
22739 (char *) "self",(char *) "win",(char *) "event", NULL
22740 };
22741
22742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(1)) SWIG_fail;
22745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22746 if (SWIG_arg_fail(2)) SWIG_fail;
22747 {
22748 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22749 if (SWIG_arg_fail(3)) SWIG_fail;
22750 if (arg3 == NULL) {
22751 SWIG_null_ref("wxIdleEvent");
22752 }
22753 if (SWIG_arg_fail(3)) SWIG_fail;
22754 }
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22772 PyObject *resultobj;
22773 wxPyApp *arg1 = (wxPyApp *) 0 ;
22774 bool result;
22775 PyObject * obj0 = 0 ;
22776 char *kwnames[] = {
22777 (char *) "self", NULL
22778 };
22779
22780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22782 if (SWIG_arg_fail(1)) SWIG_fail;
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)((wxPyApp const *)arg1)->IsActive();
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 {
22791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22792 }
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxPyApp *arg1 = (wxPyApp *) 0 ;
22802 wxWindow *arg2 = (wxWindow *) 0 ;
22803 PyObject * obj0 = 0 ;
22804 PyObject * obj1 = 0 ;
22805 char *kwnames[] = {
22806 (char *) "self",(char *) "win", NULL
22807 };
22808
22809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22811 if (SWIG_arg_fail(1)) SWIG_fail;
22812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22813 if (SWIG_arg_fail(2)) SWIG_fail;
22814 {
22815 PyThreadState* __tstate = wxPyBeginAllowThreads();
22816 (arg1)->SetTopWindow(arg2);
22817
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 Py_INCREF(Py_None); resultobj = Py_None;
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22829 PyObject *resultobj;
22830 wxPyApp *arg1 = (wxPyApp *) 0 ;
22831 wxWindow *result;
22832 PyObject * obj0 = 0 ;
22833 char *kwnames[] = {
22834 (char *) "self", NULL
22835 };
22836
22837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22839 if (SWIG_arg_fail(1)) SWIG_fail;
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22843
22844 wxPyEndAllowThreads(__tstate);
22845 if (PyErr_Occurred()) SWIG_fail;
22846 }
22847 {
22848 resultobj = wxPyMake_wxObject(result, 0);
22849 }
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22857 PyObject *resultobj;
22858 wxPyApp *arg1 = (wxPyApp *) 0 ;
22859 bool arg2 ;
22860 PyObject * obj0 = 0 ;
22861 PyObject * obj1 = 0 ;
22862 char *kwnames[] = {
22863 (char *) "self",(char *) "flag", NULL
22864 };
22865
22866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22868 if (SWIG_arg_fail(1)) SWIG_fail;
22869 {
22870 arg2 = (bool)(SWIG_As_bool(obj1));
22871 if (SWIG_arg_fail(2)) SWIG_fail;
22872 }
22873 {
22874 PyThreadState* __tstate = wxPyBeginAllowThreads();
22875 (arg1)->SetExitOnFrameDelete(arg2);
22876
22877 wxPyEndAllowThreads(__tstate);
22878 if (PyErr_Occurred()) SWIG_fail;
22879 }
22880 Py_INCREF(Py_None); resultobj = Py_None;
22881 return resultobj;
22882 fail:
22883 return NULL;
22884 }
22885
22886
22887 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22888 PyObject *resultobj;
22889 wxPyApp *arg1 = (wxPyApp *) 0 ;
22890 bool result;
22891 PyObject * obj0 = 0 ;
22892 char *kwnames[] = {
22893 (char *) "self", NULL
22894 };
22895
22896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22898 if (SWIG_arg_fail(1)) SWIG_fail;
22899 {
22900 PyThreadState* __tstate = wxPyBeginAllowThreads();
22901 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22902
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 {
22907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22908 }
22909 return resultobj;
22910 fail:
22911 return NULL;
22912 }
22913
22914
22915 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22916 PyObject *resultobj;
22917 wxPyApp *arg1 = (wxPyApp *) 0 ;
22918 bool arg2 ;
22919 PyObject * obj0 = 0 ;
22920 PyObject * obj1 = 0 ;
22921 char *kwnames[] = {
22922 (char *) "self",(char *) "flag", NULL
22923 };
22924
22925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22927 if (SWIG_arg_fail(1)) SWIG_fail;
22928 {
22929 arg2 = (bool)(SWIG_As_bool(obj1));
22930 if (SWIG_arg_fail(2)) SWIG_fail;
22931 }
22932 {
22933 PyThreadState* __tstate = wxPyBeginAllowThreads();
22934 (arg1)->SetUseBestVisual(arg2);
22935
22936 wxPyEndAllowThreads(__tstate);
22937 if (PyErr_Occurred()) SWIG_fail;
22938 }
22939 Py_INCREF(Py_None); resultobj = Py_None;
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 wxPyApp *arg1 = (wxPyApp *) 0 ;
22949 bool result;
22950 PyObject * obj0 = 0 ;
22951 char *kwnames[] = {
22952 (char *) "self", NULL
22953 };
22954
22955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22961
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 {
22966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22967 }
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22975 PyObject *resultobj;
22976 wxPyApp *arg1 = (wxPyApp *) 0 ;
22977 int arg2 ;
22978 PyObject * obj0 = 0 ;
22979 PyObject * obj1 = 0 ;
22980 char *kwnames[] = {
22981 (char *) "self",(char *) "mode", NULL
22982 };
22983
22984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 {
22988 arg2 = (int)(SWIG_As_int(obj1));
22989 if (SWIG_arg_fail(2)) SWIG_fail;
22990 }
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 (arg1)->SetPrintMode(arg2);
22994
22995 wxPyEndAllowThreads(__tstate);
22996 if (PyErr_Occurred()) SWIG_fail;
22997 }
22998 Py_INCREF(Py_None); resultobj = Py_None;
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23006 PyObject *resultobj;
23007 wxPyApp *arg1 = (wxPyApp *) 0 ;
23008 int result;
23009 PyObject * obj0 = 0 ;
23010 char *kwnames[] = {
23011 (char *) "self", NULL
23012 };
23013
23014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(1)) SWIG_fail;
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 resultobj = SWIG_From_int((int)(result));
23026 }
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj;
23035 wxPyApp *arg1 = (wxPyApp *) 0 ;
23036 int arg2 ;
23037 PyObject * obj0 = 0 ;
23038 PyObject * obj1 = 0 ;
23039 char *kwnames[] = {
23040 (char *) "self",(char *) "mode", NULL
23041 };
23042
23043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23045 if (SWIG_arg_fail(1)) SWIG_fail;
23046 {
23047 arg2 = (int)(SWIG_As_int(obj1));
23048 if (SWIG_arg_fail(2)) SWIG_fail;
23049 }
23050 {
23051 PyThreadState* __tstate = wxPyBeginAllowThreads();
23052 (arg1)->SetAssertMode(arg2);
23053
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 Py_INCREF(Py_None); resultobj = Py_None;
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23065 PyObject *resultobj;
23066 wxPyApp *arg1 = (wxPyApp *) 0 ;
23067 int result;
23068 PyObject * obj0 = 0 ;
23069 char *kwnames[] = {
23070 (char *) "self", NULL
23071 };
23072
23073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23075 if (SWIG_arg_fail(1)) SWIG_fail;
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 result = (int)(arg1)->GetAssertMode();
23079
23080 wxPyEndAllowThreads(__tstate);
23081 if (PyErr_Occurred()) SWIG_fail;
23082 }
23083 {
23084 resultobj = SWIG_From_int((int)(result));
23085 }
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23093 PyObject *resultobj;
23094 bool result;
23095 char *kwnames[] = {
23096 NULL
23097 };
23098
23099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23103
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 {
23108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23109 }
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj;
23118 long result;
23119 char *kwnames[] = {
23120 NULL
23121 };
23122
23123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = (long)wxPyApp::GetMacAboutMenuItemId();
23127
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 {
23132 resultobj = SWIG_From_long((long)(result));
23133 }
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23141 PyObject *resultobj;
23142 long result;
23143 char *kwnames[] = {
23144 NULL
23145 };
23146
23147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = SWIG_From_long((long)(result));
23157 }
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23165 PyObject *resultobj;
23166 long result;
23167 char *kwnames[] = {
23168 NULL
23169 };
23170
23171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (long)wxPyApp::GetMacExitMenuItemId();
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = SWIG_From_long((long)(result));
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxString result;
23191 char *kwnames[] = {
23192 NULL
23193 };
23194
23195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23196 {
23197 PyThreadState* __tstate = wxPyBeginAllowThreads();
23198 result = wxPyApp::GetMacHelpMenuTitleName();
23199
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 {
23204 #if wxUSE_UNICODE
23205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23206 #else
23207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23208 #endif
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 bool arg1 ;
23219 PyObject * obj0 = 0 ;
23220 char *kwnames[] = {
23221 (char *) "val", NULL
23222 };
23223
23224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23225 {
23226 arg1 = (bool)(SWIG_As_bool(obj0));
23227 if (SWIG_arg_fail(1)) SWIG_fail;
23228 }
23229 {
23230 PyThreadState* __tstate = wxPyBeginAllowThreads();
23231 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23232
23233 wxPyEndAllowThreads(__tstate);
23234 if (PyErr_Occurred()) SWIG_fail;
23235 }
23236 Py_INCREF(Py_None); resultobj = Py_None;
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23244 PyObject *resultobj;
23245 long arg1 ;
23246 PyObject * obj0 = 0 ;
23247 char *kwnames[] = {
23248 (char *) "val", NULL
23249 };
23250
23251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23252 {
23253 arg1 = (long)(SWIG_As_long(obj0));
23254 if (SWIG_arg_fail(1)) SWIG_fail;
23255 }
23256 {
23257 PyThreadState* __tstate = wxPyBeginAllowThreads();
23258 wxPyApp::SetMacAboutMenuItemId(arg1);
23259
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 Py_INCREF(Py_None); resultobj = Py_None;
23264 return resultobj;
23265 fail:
23266 return NULL;
23267 }
23268
23269
23270 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23271 PyObject *resultobj;
23272 long arg1 ;
23273 PyObject * obj0 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "val", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23279 {
23280 arg1 = (long)(SWIG_As_long(obj0));
23281 if (SWIG_arg_fail(1)) SWIG_fail;
23282 }
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23286
23287 wxPyEndAllowThreads(__tstate);
23288 if (PyErr_Occurred()) SWIG_fail;
23289 }
23290 Py_INCREF(Py_None); resultobj = Py_None;
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj;
23299 long arg1 ;
23300 PyObject * obj0 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "val", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23306 {
23307 arg1 = (long)(SWIG_As_long(obj0));
23308 if (SWIG_arg_fail(1)) SWIG_fail;
23309 }
23310 {
23311 PyThreadState* __tstate = wxPyBeginAllowThreads();
23312 wxPyApp::SetMacExitMenuItemId(arg1);
23313
23314 wxPyEndAllowThreads(__tstate);
23315 if (PyErr_Occurred()) SWIG_fail;
23316 }
23317 Py_INCREF(Py_None); resultobj = Py_None;
23318 return resultobj;
23319 fail:
23320 return NULL;
23321 }
23322
23323
23324 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj;
23326 wxString *arg1 = 0 ;
23327 bool temp1 = false ;
23328 PyObject * obj0 = 0 ;
23329 char *kwnames[] = {
23330 (char *) "val", NULL
23331 };
23332
23333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23334 {
23335 arg1 = wxString_in_helper(obj0);
23336 if (arg1 == NULL) SWIG_fail;
23337 temp1 = true;
23338 }
23339 {
23340 PyThreadState* __tstate = wxPyBeginAllowThreads();
23341 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23342
23343 wxPyEndAllowThreads(__tstate);
23344 if (PyErr_Occurred()) SWIG_fail;
23345 }
23346 Py_INCREF(Py_None); resultobj = Py_None;
23347 {
23348 if (temp1)
23349 delete arg1;
23350 }
23351 return resultobj;
23352 fail:
23353 {
23354 if (temp1)
23355 delete arg1;
23356 }
23357 return NULL;
23358 }
23359
23360
23361 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23362 PyObject *resultobj;
23363 wxPyApp *arg1 = (wxPyApp *) 0 ;
23364 PyObject * obj0 = 0 ;
23365 char *kwnames[] = {
23366 (char *) "self", NULL
23367 };
23368
23369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23371 if (SWIG_arg_fail(1)) SWIG_fail;
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 (arg1)->_BootstrapApp();
23375
23376 wxPyEndAllowThreads(__tstate);
23377 if (PyErr_Occurred()) SWIG_fail;
23378 }
23379 Py_INCREF(Py_None); resultobj = Py_None;
23380 return resultobj;
23381 fail:
23382 return NULL;
23383 }
23384
23385
23386 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23387 PyObject *resultobj;
23388 int result;
23389 char *kwnames[] = {
23390 NULL
23391 };
23392
23393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23394 {
23395 PyThreadState* __tstate = wxPyBeginAllowThreads();
23396 result = (int)wxPyApp::GetComCtl32Version();
23397
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 {
23402 resultobj = SWIG_From_int((int)(result));
23403 }
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23411 PyObject *obj;
23412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23413 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23414 Py_INCREF(obj);
23415 return Py_BuildValue((char *)"");
23416 }
23417 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 char *kwnames[] = {
23420 NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 wxExit();
23427
23428 wxPyEndAllowThreads(__tstate);
23429 if (PyErr_Occurred()) SWIG_fail;
23430 }
23431 Py_INCREF(Py_None); resultobj = Py_None;
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23439 PyObject *resultobj;
23440 bool result;
23441 char *kwnames[] = {
23442 NULL
23443 };
23444
23445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23446 {
23447 PyThreadState* __tstate = wxPyBeginAllowThreads();
23448 result = (bool)wxYield();
23449
23450 wxPyEndAllowThreads(__tstate);
23451 if (PyErr_Occurred()) SWIG_fail;
23452 }
23453 {
23454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23455 }
23456 return resultobj;
23457 fail:
23458 return NULL;
23459 }
23460
23461
23462 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj;
23464 bool result;
23465 char *kwnames[] = {
23466 NULL
23467 };
23468
23469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23470 {
23471 PyThreadState* __tstate = wxPyBeginAllowThreads();
23472 result = (bool)wxYieldIfNeeded();
23473
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 {
23478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23479 }
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23487 PyObject *resultobj;
23488 wxWindow *arg1 = (wxWindow *) NULL ;
23489 bool arg2 = (bool) false ;
23490 bool result;
23491 PyObject * obj0 = 0 ;
23492 PyObject * obj1 = 0 ;
23493 char *kwnames[] = {
23494 (char *) "win",(char *) "onlyIfNeeded", NULL
23495 };
23496
23497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23498 if (obj0) {
23499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(1)) SWIG_fail;
23501 }
23502 if (obj1) {
23503 {
23504 arg2 = (bool)(SWIG_As_bool(obj1));
23505 if (SWIG_arg_fail(2)) SWIG_fail;
23506 }
23507 }
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (bool)wxSafeYield(arg1,arg2);
23511
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj;
23526 char *kwnames[] = {
23527 NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 wxWakeUpIdle();
23534
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 Py_INCREF(Py_None); resultobj = Py_None;
23539 return resultobj;
23540 fail:
23541 return NULL;
23542 }
23543
23544
23545 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23546 PyObject *resultobj;
23547 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23548 wxEvent *arg2 = 0 ;
23549 PyObject * obj0 = 0 ;
23550 PyObject * obj1 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "dest",(char *) "event", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23557 if (SWIG_arg_fail(1)) SWIG_fail;
23558 {
23559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23560 if (SWIG_arg_fail(2)) SWIG_fail;
23561 if (arg2 == NULL) {
23562 SWIG_null_ref("wxEvent");
23563 }
23564 if (SWIG_arg_fail(2)) SWIG_fail;
23565 }
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 wxPostEvent(arg1,*arg2);
23569
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 Py_INCREF(Py_None); resultobj = Py_None;
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj;
23582 char *kwnames[] = {
23583 NULL
23584 };
23585
23586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 wxApp_CleanUp();
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 Py_INCREF(Py_None); resultobj = Py_None;
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23602 PyObject *resultobj;
23603 wxPyApp *result;
23604 char *kwnames[] = {
23605 NULL
23606 };
23607
23608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23609 {
23610 PyThreadState* __tstate = wxPyBeginAllowThreads();
23611 result = (wxPyApp *)wxPyGetApp();
23612
23613 wxPyEndAllowThreads(__tstate);
23614 if (PyErr_Occurred()) SWIG_fail;
23615 }
23616 {
23617 resultobj = wxPyMake_wxObject(result, 0);
23618 }
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj;
23627 char *arg1 = (char *) 0 ;
23628 PyObject * obj0 = 0 ;
23629 char *kwnames[] = {
23630 (char *) "encoding", NULL
23631 };
23632
23633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23634 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23635 SWIG_arg_fail(1);SWIG_fail;
23636 }
23637 {
23638 PyThreadState* __tstate = wxPyBeginAllowThreads();
23639 wxSetDefaultPyEncoding((char const *)arg1);
23640
23641 wxPyEndAllowThreads(__tstate);
23642 if (PyErr_Occurred()) SWIG_fail;
23643 }
23644 Py_INCREF(Py_None); resultobj = Py_None;
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj;
23653 char *result;
23654 char *kwnames[] = {
23655 NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (char *)wxGetDefaultPyEncoding();
23662
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 resultobj = SWIG_FromCharPtr(result);
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj;
23675 wxEventLoop *result;
23676 char *kwnames[] = {
23677 NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (wxEventLoop *)new wxEventLoop();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj;
23697 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23698 PyObject * obj0 = 0 ;
23699 char *kwnames[] = {
23700 (char *) "self", NULL
23701 };
23702
23703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23705 if (SWIG_arg_fail(1)) SWIG_fail;
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 delete arg1;
23709
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 Py_INCREF(Py_None); resultobj = Py_None;
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23721 PyObject *resultobj;
23722 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23723 int result;
23724 PyObject * obj0 = 0 ;
23725 char *kwnames[] = {
23726 (char *) "self", NULL
23727 };
23728
23729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23731 if (SWIG_arg_fail(1)) SWIG_fail;
23732 {
23733 PyThreadState* __tstate = wxPyBeginAllowThreads();
23734 result = (int)(arg1)->Run();
23735
23736 wxPyEndAllowThreads(__tstate);
23737 if (PyErr_Occurred()) SWIG_fail;
23738 }
23739 {
23740 resultobj = SWIG_From_int((int)(result));
23741 }
23742 return resultobj;
23743 fail:
23744 return NULL;
23745 }
23746
23747
23748 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23749 PyObject *resultobj;
23750 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23751 int arg2 = (int) 0 ;
23752 PyObject * obj0 = 0 ;
23753 PyObject * obj1 = 0 ;
23754 char *kwnames[] = {
23755 (char *) "self",(char *) "rc", NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23760 if (SWIG_arg_fail(1)) SWIG_fail;
23761 if (obj1) {
23762 {
23763 arg2 = (int)(SWIG_As_int(obj1));
23764 if (SWIG_arg_fail(2)) SWIG_fail;
23765 }
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 (arg1)->Exit(arg2);
23770
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 Py_INCREF(Py_None); resultobj = Py_None;
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23782 PyObject *resultobj;
23783 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23784 bool result;
23785 PyObject * obj0 = 0 ;
23786 char *kwnames[] = {
23787 (char *) "self", NULL
23788 };
23789
23790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23792 if (SWIG_arg_fail(1)) SWIG_fail;
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 result = (bool)((wxEventLoop const *)arg1)->Pending();
23796
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj;
23811 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23812 bool result;
23813 PyObject * obj0 = 0 ;
23814 char *kwnames[] = {
23815 (char *) "self", NULL
23816 };
23817
23818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23820 if (SWIG_arg_fail(1)) SWIG_fail;
23821 {
23822 PyThreadState* __tstate = wxPyBeginAllowThreads();
23823 result = (bool)(arg1)->Dispatch();
23824
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 {
23829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23830 }
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj;
23839 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23840 bool result;
23841 PyObject * obj0 = 0 ;
23842 char *kwnames[] = {
23843 (char *) "self", NULL
23844 };
23845
23846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23848 if (SWIG_arg_fail(1)) SWIG_fail;
23849 {
23850 PyThreadState* __tstate = wxPyBeginAllowThreads();
23851 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23852
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 {
23857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23858 }
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23866 PyObject *resultobj;
23867 wxEventLoop *result;
23868 char *kwnames[] = {
23869 NULL
23870 };
23871
23872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23873 {
23874 PyThreadState* __tstate = wxPyBeginAllowThreads();
23875 result = (wxEventLoop *)wxEventLoop::GetActive();
23876
23877 wxPyEndAllowThreads(__tstate);
23878 if (PyErr_Occurred()) SWIG_fail;
23879 }
23880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23890 PyObject * obj0 = 0 ;
23891 char *kwnames[] = {
23892 (char *) "loop", NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23897 if (SWIG_arg_fail(1)) SWIG_fail;
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 wxEventLoop::SetActive(arg1);
23901
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 Py_INCREF(Py_None); resultobj = Py_None;
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23913 PyObject *obj;
23914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23915 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23916 Py_INCREF(obj);
23917 return Py_BuildValue((char *)"");
23918 }
23919 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 int arg1 = (int) 0 ;
23922 int arg2 = (int) 0 ;
23923 int arg3 = (int) 0 ;
23924 wxAcceleratorEntry *result;
23925 PyObject * obj0 = 0 ;
23926 PyObject * obj1 = 0 ;
23927 PyObject * obj2 = 0 ;
23928 char *kwnames[] = {
23929 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23930 };
23931
23932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23933 if (obj0) {
23934 {
23935 arg1 = (int)(SWIG_As_int(obj0));
23936 if (SWIG_arg_fail(1)) SWIG_fail;
23937 }
23938 }
23939 if (obj1) {
23940 {
23941 arg2 = (int)(SWIG_As_int(obj1));
23942 if (SWIG_arg_fail(2)) SWIG_fail;
23943 }
23944 }
23945 if (obj2) {
23946 {
23947 arg3 = (int)(SWIG_As_int(obj2));
23948 if (SWIG_arg_fail(3)) SWIG_fail;
23949 }
23950 }
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23954
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23966 PyObject *resultobj;
23967 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23968 PyObject * obj0 = 0 ;
23969 char *kwnames[] = {
23970 (char *) "self", NULL
23971 };
23972
23973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23975 if (SWIG_arg_fail(1)) SWIG_fail;
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 delete arg1;
23979
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 Py_INCREF(Py_None); resultobj = Py_None;
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23991 PyObject *resultobj;
23992 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23993 int arg2 ;
23994 int arg3 ;
23995 int arg4 ;
23996 PyObject * obj0 = 0 ;
23997 PyObject * obj1 = 0 ;
23998 PyObject * obj2 = 0 ;
23999 PyObject * obj3 = 0 ;
24000 char *kwnames[] = {
24001 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24002 };
24003
24004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24006 if (SWIG_arg_fail(1)) SWIG_fail;
24007 {
24008 arg2 = (int)(SWIG_As_int(obj1));
24009 if (SWIG_arg_fail(2)) SWIG_fail;
24010 }
24011 {
24012 arg3 = (int)(SWIG_As_int(obj2));
24013 if (SWIG_arg_fail(3)) SWIG_fail;
24014 }
24015 {
24016 arg4 = (int)(SWIG_As_int(obj3));
24017 if (SWIG_arg_fail(4)) SWIG_fail;
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 (arg1)->Set(arg2,arg3,arg4);
24022
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 Py_INCREF(Py_None); resultobj = Py_None;
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj;
24035 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24036 int result;
24037 PyObject * obj0 = 0 ;
24038 char *kwnames[] = {
24039 (char *) "self", NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24044 if (SWIG_arg_fail(1)) SWIG_fail;
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = (int)(arg1)->GetFlags();
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 {
24053 resultobj = SWIG_From_int((int)(result));
24054 }
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj;
24063 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24064 int result;
24065 PyObject * obj0 = 0 ;
24066 char *kwnames[] = {
24067 (char *) "self", NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24072 if (SWIG_arg_fail(1)) SWIG_fail;
24073 {
24074 PyThreadState* __tstate = wxPyBeginAllowThreads();
24075 result = (int)(arg1)->GetKeyCode();
24076
24077 wxPyEndAllowThreads(__tstate);
24078 if (PyErr_Occurred()) SWIG_fail;
24079 }
24080 {
24081 resultobj = SWIG_From_int((int)(result));
24082 }
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24092 int result;
24093 PyObject * obj0 = 0 ;
24094 char *kwnames[] = {
24095 (char *) "self", NULL
24096 };
24097
24098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24100 if (SWIG_arg_fail(1)) SWIG_fail;
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 result = (int)(arg1)->GetCommand();
24104
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 {
24109 resultobj = SWIG_From_int((int)(result));
24110 }
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24118 PyObject *obj;
24119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24120 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24121 Py_INCREF(obj);
24122 return Py_BuildValue((char *)"");
24123 }
24124 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24125 PyObject *resultobj;
24126 int arg1 ;
24127 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24128 wxAcceleratorTable *result;
24129 PyObject * obj0 = 0 ;
24130 char *kwnames[] = {
24131 (char *) "n", NULL
24132 };
24133
24134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24135 {
24136 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24137 if (arg2) arg1 = PyList_Size(obj0);
24138 else arg1 = 0;
24139 }
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24143
24144 wxPyEndAllowThreads(__tstate);
24145 if (PyErr_Occurred()) SWIG_fail;
24146 }
24147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24148 {
24149 delete [] arg2;
24150 }
24151 return resultobj;
24152 fail:
24153 {
24154 delete [] arg2;
24155 }
24156 return NULL;
24157 }
24158
24159
24160 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24161 PyObject *resultobj;
24162 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24163 PyObject * obj0 = 0 ;
24164 char *kwnames[] = {
24165 (char *) "self", NULL
24166 };
24167
24168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24170 if (SWIG_arg_fail(1)) SWIG_fail;
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 delete arg1;
24174
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 Py_INCREF(Py_None); resultobj = Py_None;
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj;
24187 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24188 bool result;
24189 PyObject * obj0 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "self", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24214 PyObject *obj;
24215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24216 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24217 Py_INCREF(obj);
24218 return Py_BuildValue((char *)"");
24219 }
24220 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24221 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24222 return 1;
24223 }
24224
24225
24226 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24227 PyObject *pyobj;
24228
24229 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24230 return pyobj;
24231 }
24232
24233
24234 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24235 PyObject *resultobj;
24236 wxString *arg1 = 0 ;
24237 wxAcceleratorEntry *result;
24238 bool temp1 = false ;
24239 PyObject * obj0 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "label", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24245 {
24246 arg1 = wxString_in_helper(obj0);
24247 if (arg1 == NULL) SWIG_fail;
24248 temp1 = true;
24249 }
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24253
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24258 {
24259 if (temp1)
24260 delete arg1;
24261 }
24262 return resultobj;
24263 fail:
24264 {
24265 if (temp1)
24266 delete arg1;
24267 }
24268 return NULL;
24269 }
24270
24271
24272 static int _wrap_PanelNameStr_set(PyObject *) {
24273 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24274 return 1;
24275 }
24276
24277
24278 static PyObject *_wrap_PanelNameStr_get(void) {
24279 PyObject *pyobj;
24280
24281 {
24282 #if wxUSE_UNICODE
24283 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24284 #else
24285 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24286 #endif
24287 }
24288 return pyobj;
24289 }
24290
24291
24292 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj;
24294 wxVisualAttributes *result;
24295 char *kwnames[] = {
24296 NULL
24297 };
24298
24299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24300 {
24301 PyThreadState* __tstate = wxPyBeginAllowThreads();
24302 result = (wxVisualAttributes *)new_wxVisualAttributes();
24303
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj;
24316 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24317 PyObject * obj0 = 0 ;
24318 char *kwnames[] = {
24319 (char *) "self", NULL
24320 };
24321
24322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24324 if (SWIG_arg_fail(1)) SWIG_fail;
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 delete_wxVisualAttributes(arg1);
24328
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 Py_INCREF(Py_None); resultobj = Py_None;
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24340 PyObject *resultobj;
24341 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24342 wxFont *arg2 = (wxFont *) 0 ;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char *kwnames[] = {
24346 (char *) "self",(char *) "font", NULL
24347 };
24348
24349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(1)) SWIG_fail;
24352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24353 if (SWIG_arg_fail(2)) SWIG_fail;
24354 if (arg1) (arg1)->font = *arg2;
24355
24356 Py_INCREF(Py_None); resultobj = Py_None;
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24366 wxFont *result;
24367 PyObject * obj0 = 0 ;
24368 char *kwnames[] = {
24369 (char *) "self", NULL
24370 };
24371
24372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24374 if (SWIG_arg_fail(1)) SWIG_fail;
24375 result = (wxFont *)& ((arg1)->font);
24376
24377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24385 PyObject *resultobj;
24386 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24387 wxColour *arg2 = (wxColour *) 0 ;
24388 PyObject * obj0 = 0 ;
24389 PyObject * obj1 = 0 ;
24390 char *kwnames[] = {
24391 (char *) "self",(char *) "colFg", NULL
24392 };
24393
24394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24396 if (SWIG_arg_fail(1)) SWIG_fail;
24397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24398 if (SWIG_arg_fail(2)) SWIG_fail;
24399 if (arg1) (arg1)->colFg = *arg2;
24400
24401 Py_INCREF(Py_None); resultobj = Py_None;
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24411 wxColour *result;
24412 PyObject * obj0 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 result = (wxColour *)& ((arg1)->colFg);
24421
24422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24430 PyObject *resultobj;
24431 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24432 wxColour *arg2 = (wxColour *) 0 ;
24433 PyObject * obj0 = 0 ;
24434 PyObject * obj1 = 0 ;
24435 char *kwnames[] = {
24436 (char *) "self",(char *) "colBg", NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24441 if (SWIG_arg_fail(1)) SWIG_fail;
24442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24443 if (SWIG_arg_fail(2)) SWIG_fail;
24444 if (arg1) (arg1)->colBg = *arg2;
24445
24446 Py_INCREF(Py_None); resultobj = Py_None;
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj;
24455 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24456 wxColour *result;
24457 PyObject * obj0 = 0 ;
24458 char *kwnames[] = {
24459 (char *) "self", NULL
24460 };
24461
24462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24464 if (SWIG_arg_fail(1)) SWIG_fail;
24465 result = (wxColour *)& ((arg1)->colBg);
24466
24467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24468 return resultobj;
24469 fail:
24470 return NULL;
24471 }
24472
24473
24474 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24475 PyObject *obj;
24476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24477 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24478 Py_INCREF(obj);
24479 return Py_BuildValue((char *)"");
24480 }
24481 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj;
24483 wxWindow *arg1 = (wxWindow *) 0 ;
24484 int arg2 = (int) (int)-1 ;
24485 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24486 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24487 wxSize const &arg4_defvalue = wxDefaultSize ;
24488 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24489 long arg5 = (long) 0 ;
24490 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24491 wxString *arg6 = (wxString *) &arg6_defvalue ;
24492 wxWindow *result;
24493 wxPoint temp3 ;
24494 wxSize temp4 ;
24495 bool temp6 = false ;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 PyObject * obj2 = 0 ;
24499 PyObject * obj3 = 0 ;
24500 PyObject * obj4 = 0 ;
24501 PyObject * obj5 = 0 ;
24502 char *kwnames[] = {
24503 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24504 };
24505
24506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(1)) SWIG_fail;
24509 if (obj1) {
24510 {
24511 arg2 = (int const)(SWIG_As_int(obj1));
24512 if (SWIG_arg_fail(2)) SWIG_fail;
24513 }
24514 }
24515 if (obj2) {
24516 {
24517 arg3 = &temp3;
24518 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24519 }
24520 }
24521 if (obj3) {
24522 {
24523 arg4 = &temp4;
24524 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24525 }
24526 }
24527 if (obj4) {
24528 {
24529 arg5 = (long)(SWIG_As_long(obj4));
24530 if (SWIG_arg_fail(5)) SWIG_fail;
24531 }
24532 }
24533 if (obj5) {
24534 {
24535 arg6 = wxString_in_helper(obj5);
24536 if (arg6 == NULL) SWIG_fail;
24537 temp6 = true;
24538 }
24539 }
24540 {
24541 if (!wxPyCheckForApp()) SWIG_fail;
24542 PyThreadState* __tstate = wxPyBeginAllowThreads();
24543 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24544
24545 wxPyEndAllowThreads(__tstate);
24546 if (PyErr_Occurred()) SWIG_fail;
24547 }
24548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24549 {
24550 if (temp6)
24551 delete arg6;
24552 }
24553 return resultobj;
24554 fail:
24555 {
24556 if (temp6)
24557 delete arg6;
24558 }
24559 return NULL;
24560 }
24561
24562
24563 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24564 PyObject *resultobj;
24565 wxWindow *result;
24566 char *kwnames[] = {
24567 NULL
24568 };
24569
24570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24571 {
24572 if (!wxPyCheckForApp()) SWIG_fail;
24573 PyThreadState* __tstate = wxPyBeginAllowThreads();
24574 result = (wxWindow *)new wxWindow();
24575
24576 wxPyEndAllowThreads(__tstate);
24577 if (PyErr_Occurred()) SWIG_fail;
24578 }
24579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj;
24588 wxWindow *arg1 = (wxWindow *) 0 ;
24589 wxWindow *arg2 = (wxWindow *) 0 ;
24590 int arg3 = (int) (int)-1 ;
24591 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24592 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24593 wxSize const &arg5_defvalue = wxDefaultSize ;
24594 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24595 long arg6 = (long) 0 ;
24596 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24597 wxString *arg7 = (wxString *) &arg7_defvalue ;
24598 bool result;
24599 wxPoint temp4 ;
24600 wxSize temp5 ;
24601 bool temp7 = false ;
24602 PyObject * obj0 = 0 ;
24603 PyObject * obj1 = 0 ;
24604 PyObject * obj2 = 0 ;
24605 PyObject * obj3 = 0 ;
24606 PyObject * obj4 = 0 ;
24607 PyObject * obj5 = 0 ;
24608 PyObject * obj6 = 0 ;
24609 char *kwnames[] = {
24610 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24611 };
24612
24613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24615 if (SWIG_arg_fail(1)) SWIG_fail;
24616 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(2)) SWIG_fail;
24618 if (obj2) {
24619 {
24620 arg3 = (int const)(SWIG_As_int(obj2));
24621 if (SWIG_arg_fail(3)) SWIG_fail;
24622 }
24623 }
24624 if (obj3) {
24625 {
24626 arg4 = &temp4;
24627 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24628 }
24629 }
24630 if (obj4) {
24631 {
24632 arg5 = &temp5;
24633 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24634 }
24635 }
24636 if (obj5) {
24637 {
24638 arg6 = (long)(SWIG_As_long(obj5));
24639 if (SWIG_arg_fail(6)) SWIG_fail;
24640 }
24641 }
24642 if (obj6) {
24643 {
24644 arg7 = wxString_in_helper(obj6);
24645 if (arg7 == NULL) SWIG_fail;
24646 temp7 = true;
24647 }
24648 }
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24652
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 {
24657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24658 }
24659 {
24660 if (temp7)
24661 delete arg7;
24662 }
24663 return resultobj;
24664 fail:
24665 {
24666 if (temp7)
24667 delete arg7;
24668 }
24669 return NULL;
24670 }
24671
24672
24673 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24674 PyObject *resultobj;
24675 wxWindow *arg1 = (wxWindow *) 0 ;
24676 bool arg2 = (bool) false ;
24677 bool result;
24678 PyObject * obj0 = 0 ;
24679 PyObject * obj1 = 0 ;
24680 char *kwnames[] = {
24681 (char *) "self",(char *) "force", NULL
24682 };
24683
24684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24686 if (SWIG_arg_fail(1)) SWIG_fail;
24687 if (obj1) {
24688 {
24689 arg2 = (bool)(SWIG_As_bool(obj1));
24690 if (SWIG_arg_fail(2)) SWIG_fail;
24691 }
24692 }
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (bool)(arg1)->Close(arg2);
24696
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 {
24701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702 }
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj;
24711 wxWindow *arg1 = (wxWindow *) 0 ;
24712 bool result;
24713 PyObject * obj0 = 0 ;
24714 char *kwnames[] = {
24715 (char *) "self", NULL
24716 };
24717
24718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24720 if (SWIG_arg_fail(1)) SWIG_fail;
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 result = (bool)(arg1)->Destroy();
24724
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 {
24729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24730 }
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24738 PyObject *resultobj;
24739 wxWindow *arg1 = (wxWindow *) 0 ;
24740 bool result;
24741 PyObject * obj0 = 0 ;
24742 char *kwnames[] = {
24743 (char *) "self", NULL
24744 };
24745
24746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24748 if (SWIG_arg_fail(1)) SWIG_fail;
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 result = (bool)(arg1)->DestroyChildren();
24752
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 {
24757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24758 }
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj;
24767 wxWindow *arg1 = (wxWindow *) 0 ;
24768 bool result;
24769 PyObject * obj0 = 0 ;
24770 char *kwnames[] = {
24771 (char *) "self", NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24776 if (SWIG_arg_fail(1)) SWIG_fail;
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24780
24781 wxPyEndAllowThreads(__tstate);
24782 if (PyErr_Occurred()) SWIG_fail;
24783 }
24784 {
24785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24786 }
24787 return resultobj;
24788 fail:
24789 return NULL;
24790 }
24791
24792
24793 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24794 PyObject *resultobj;
24795 wxWindow *arg1 = (wxWindow *) 0 ;
24796 wxString *arg2 = 0 ;
24797 bool temp2 = false ;
24798 PyObject * obj0 = 0 ;
24799 PyObject * obj1 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self",(char *) "title", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 {
24808 arg2 = wxString_in_helper(obj1);
24809 if (arg2 == NULL) SWIG_fail;
24810 temp2 = true;
24811 }
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 (arg1)->SetTitle((wxString const &)*arg2);
24815
24816 wxPyEndAllowThreads(__tstate);
24817 if (PyErr_Occurred()) SWIG_fail;
24818 }
24819 Py_INCREF(Py_None); resultobj = Py_None;
24820 {
24821 if (temp2)
24822 delete arg2;
24823 }
24824 return resultobj;
24825 fail:
24826 {
24827 if (temp2)
24828 delete arg2;
24829 }
24830 return NULL;
24831 }
24832
24833
24834 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24835 PyObject *resultobj;
24836 wxWindow *arg1 = (wxWindow *) 0 ;
24837 wxString result;
24838 PyObject * obj0 = 0 ;
24839 char *kwnames[] = {
24840 (char *) "self", NULL
24841 };
24842
24843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24845 if (SWIG_arg_fail(1)) SWIG_fail;
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = ((wxWindow const *)arg1)->GetTitle();
24849
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 #if wxUSE_UNICODE
24855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24856 #else
24857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24858 #endif
24859 }
24860 return resultobj;
24861 fail:
24862 return NULL;
24863 }
24864
24865
24866 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24867 PyObject *resultobj;
24868 wxWindow *arg1 = (wxWindow *) 0 ;
24869 wxString *arg2 = 0 ;
24870 bool temp2 = false ;
24871 PyObject * obj0 = 0 ;
24872 PyObject * obj1 = 0 ;
24873 char *kwnames[] = {
24874 (char *) "self",(char *) "label", NULL
24875 };
24876
24877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24879 if (SWIG_arg_fail(1)) SWIG_fail;
24880 {
24881 arg2 = wxString_in_helper(obj1);
24882 if (arg2 == NULL) SWIG_fail;
24883 temp2 = true;
24884 }
24885 {
24886 PyThreadState* __tstate = wxPyBeginAllowThreads();
24887 (arg1)->SetLabel((wxString const &)*arg2);
24888
24889 wxPyEndAllowThreads(__tstate);
24890 if (PyErr_Occurred()) SWIG_fail;
24891 }
24892 Py_INCREF(Py_None); resultobj = Py_None;
24893 {
24894 if (temp2)
24895 delete arg2;
24896 }
24897 return resultobj;
24898 fail:
24899 {
24900 if (temp2)
24901 delete arg2;
24902 }
24903 return NULL;
24904 }
24905
24906
24907 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24908 PyObject *resultobj;
24909 wxWindow *arg1 = (wxWindow *) 0 ;
24910 wxString result;
24911 PyObject * obj0 = 0 ;
24912 char *kwnames[] = {
24913 (char *) "self", NULL
24914 };
24915
24916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(1)) SWIG_fail;
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = ((wxWindow const *)arg1)->GetLabel();
24922
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 #if wxUSE_UNICODE
24928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24929 #else
24930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24931 #endif
24932 }
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj;
24941 wxWindow *arg1 = (wxWindow *) 0 ;
24942 wxString *arg2 = 0 ;
24943 bool temp2 = false ;
24944 PyObject * obj0 = 0 ;
24945 PyObject * obj1 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self",(char *) "name", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 arg2 = wxString_in_helper(obj1);
24955 if (arg2 == NULL) SWIG_fail;
24956 temp2 = true;
24957 }
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 (arg1)->SetName((wxString const &)*arg2);
24961
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 Py_INCREF(Py_None); resultobj = Py_None;
24966 {
24967 if (temp2)
24968 delete arg2;
24969 }
24970 return resultobj;
24971 fail:
24972 {
24973 if (temp2)
24974 delete arg2;
24975 }
24976 return NULL;
24977 }
24978
24979
24980 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24981 PyObject *resultobj;
24982 wxWindow *arg1 = (wxWindow *) 0 ;
24983 wxString result;
24984 PyObject * obj0 = 0 ;
24985 char *kwnames[] = {
24986 (char *) "self", NULL
24987 };
24988
24989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24991 if (SWIG_arg_fail(1)) SWIG_fail;
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = ((wxWindow const *)arg1)->GetName();
24995
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 {
25000 #if wxUSE_UNICODE
25001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25002 #else
25003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25004 #endif
25005 }
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj;
25014 wxWindow *arg1 = (wxWindow *) 0 ;
25015 wxWindowVariant arg2 ;
25016 PyObject * obj0 = 0 ;
25017 PyObject * obj1 = 0 ;
25018 char *kwnames[] = {
25019 (char *) "self",(char *) "variant", NULL
25020 };
25021
25022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25024 if (SWIG_arg_fail(1)) SWIG_fail;
25025 {
25026 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25027 if (SWIG_arg_fail(2)) SWIG_fail;
25028 }
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25032
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 Py_INCREF(Py_None); resultobj = Py_None;
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj;
25045 wxWindow *arg1 = (wxWindow *) 0 ;
25046 wxWindowVariant result;
25047 PyObject * obj0 = 0 ;
25048 char *kwnames[] = {
25049 (char *) "self", NULL
25050 };
25051
25052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(1)) SWIG_fail;
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25058
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 resultobj = SWIG_From_int((result));
25063 return resultobj;
25064 fail:
25065 return NULL;
25066 }
25067
25068
25069 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25070 PyObject *resultobj;
25071 wxWindow *arg1 = (wxWindow *) 0 ;
25072 int arg2 ;
25073 PyObject * obj0 = 0 ;
25074 PyObject * obj1 = 0 ;
25075 char *kwnames[] = {
25076 (char *) "self",(char *) "winid", NULL
25077 };
25078
25079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25081 if (SWIG_arg_fail(1)) SWIG_fail;
25082 {
25083 arg2 = (int)(SWIG_As_int(obj1));
25084 if (SWIG_arg_fail(2)) SWIG_fail;
25085 }
25086 {
25087 PyThreadState* __tstate = wxPyBeginAllowThreads();
25088 (arg1)->SetId(arg2);
25089
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 Py_INCREF(Py_None); resultobj = Py_None;
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25101 PyObject *resultobj;
25102 wxWindow *arg1 = (wxWindow *) 0 ;
25103 int result;
25104 PyObject * obj0 = 0 ;
25105 char *kwnames[] = {
25106 (char *) "self", NULL
25107 };
25108
25109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25111 if (SWIG_arg_fail(1)) SWIG_fail;
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = (int)((wxWindow const *)arg1)->GetId();
25115
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 {
25120 resultobj = SWIG_From_int((int)(result));
25121 }
25122 return resultobj;
25123 fail:
25124 return NULL;
25125 }
25126
25127
25128 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25129 PyObject *resultobj;
25130 int result;
25131 char *kwnames[] = {
25132 NULL
25133 };
25134
25135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (int)wxWindow::NewControlId();
25139
25140 wxPyEndAllowThreads(__tstate);
25141 if (PyErr_Occurred()) SWIG_fail;
25142 }
25143 {
25144 resultobj = SWIG_From_int((int)(result));
25145 }
25146 return resultobj;
25147 fail:
25148 return NULL;
25149 }
25150
25151
25152 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25153 PyObject *resultobj;
25154 int arg1 ;
25155 int result;
25156 PyObject * obj0 = 0 ;
25157 char *kwnames[] = {
25158 (char *) "winid", NULL
25159 };
25160
25161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25162 {
25163 arg1 = (int)(SWIG_As_int(obj0));
25164 if (SWIG_arg_fail(1)) SWIG_fail;
25165 }
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = (int)wxWindow::NextControlId(arg1);
25169
25170 wxPyEndAllowThreads(__tstate);
25171 if (PyErr_Occurred()) SWIG_fail;
25172 }
25173 {
25174 resultobj = SWIG_From_int((int)(result));
25175 }
25176 return resultobj;
25177 fail:
25178 return NULL;
25179 }
25180
25181
25182 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25183 PyObject *resultobj;
25184 int arg1 ;
25185 int result;
25186 PyObject * obj0 = 0 ;
25187 char *kwnames[] = {
25188 (char *) "winid", NULL
25189 };
25190
25191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25192 {
25193 arg1 = (int)(SWIG_As_int(obj0));
25194 if (SWIG_arg_fail(1)) SWIG_fail;
25195 }
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (int)wxWindow::PrevControlId(arg1);
25199
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 {
25204 resultobj = SWIG_From_int((int)(result));
25205 }
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25213 PyObject *resultobj;
25214 wxWindow *arg1 = (wxWindow *) 0 ;
25215 wxSize *arg2 = 0 ;
25216 wxSize temp2 ;
25217 PyObject * obj0 = 0 ;
25218 PyObject * obj1 = 0 ;
25219 char *kwnames[] = {
25220 (char *) "self",(char *) "size", NULL
25221 };
25222
25223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25225 if (SWIG_arg_fail(1)) SWIG_fail;
25226 {
25227 arg2 = &temp2;
25228 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25229 }
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 (arg1)->SetSize((wxSize const &)*arg2);
25233
25234 wxPyEndAllowThreads(__tstate);
25235 if (PyErr_Occurred()) SWIG_fail;
25236 }
25237 Py_INCREF(Py_None); resultobj = Py_None;
25238 return resultobj;
25239 fail:
25240 return NULL;
25241 }
25242
25243
25244 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25245 PyObject *resultobj;
25246 wxWindow *arg1 = (wxWindow *) 0 ;
25247 int arg2 ;
25248 int arg3 ;
25249 int arg4 ;
25250 int arg5 ;
25251 int arg6 = (int) wxSIZE_AUTO ;
25252 PyObject * obj0 = 0 ;
25253 PyObject * obj1 = 0 ;
25254 PyObject * obj2 = 0 ;
25255 PyObject * obj3 = 0 ;
25256 PyObject * obj4 = 0 ;
25257 PyObject * obj5 = 0 ;
25258 char *kwnames[] = {
25259 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25260 };
25261
25262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25264 if (SWIG_arg_fail(1)) SWIG_fail;
25265 {
25266 arg2 = (int)(SWIG_As_int(obj1));
25267 if (SWIG_arg_fail(2)) SWIG_fail;
25268 }
25269 {
25270 arg3 = (int)(SWIG_As_int(obj2));
25271 if (SWIG_arg_fail(3)) SWIG_fail;
25272 }
25273 {
25274 arg4 = (int)(SWIG_As_int(obj3));
25275 if (SWIG_arg_fail(4)) SWIG_fail;
25276 }
25277 {
25278 arg5 = (int)(SWIG_As_int(obj4));
25279 if (SWIG_arg_fail(5)) SWIG_fail;
25280 }
25281 if (obj5) {
25282 {
25283 arg6 = (int)(SWIG_As_int(obj5));
25284 if (SWIG_arg_fail(6)) SWIG_fail;
25285 }
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 Py_INCREF(Py_None); resultobj = Py_None;
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj;
25303 wxWindow *arg1 = (wxWindow *) 0 ;
25304 wxRect *arg2 = 0 ;
25305 int arg3 = (int) wxSIZE_AUTO ;
25306 wxRect temp2 ;
25307 PyObject * obj0 = 0 ;
25308 PyObject * obj1 = 0 ;
25309 PyObject * obj2 = 0 ;
25310 char *kwnames[] = {
25311 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25312 };
25313
25314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25316 if (SWIG_arg_fail(1)) SWIG_fail;
25317 {
25318 arg2 = &temp2;
25319 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25320 }
25321 if (obj2) {
25322 {
25323 arg3 = (int)(SWIG_As_int(obj2));
25324 if (SWIG_arg_fail(3)) SWIG_fail;
25325 }
25326 }
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 Py_INCREF(Py_None); resultobj = Py_None;
25335 return resultobj;
25336 fail:
25337 return NULL;
25338 }
25339
25340
25341 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25342 PyObject *resultobj;
25343 wxWindow *arg1 = (wxWindow *) 0 ;
25344 int arg2 ;
25345 int arg3 ;
25346 PyObject * obj0 = 0 ;
25347 PyObject * obj1 = 0 ;
25348 PyObject * obj2 = 0 ;
25349 char *kwnames[] = {
25350 (char *) "self",(char *) "width",(char *) "height", NULL
25351 };
25352
25353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25355 if (SWIG_arg_fail(1)) SWIG_fail;
25356 {
25357 arg2 = (int)(SWIG_As_int(obj1));
25358 if (SWIG_arg_fail(2)) SWIG_fail;
25359 }
25360 {
25361 arg3 = (int)(SWIG_As_int(obj2));
25362 if (SWIG_arg_fail(3)) SWIG_fail;
25363 }
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 (arg1)->SetSize(arg2,arg3);
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 Py_INCREF(Py_None); resultobj = Py_None;
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj;
25380 wxWindow *arg1 = (wxWindow *) 0 ;
25381 wxPoint *arg2 = 0 ;
25382 int arg3 = (int) wxSIZE_USE_EXISTING ;
25383 wxPoint temp2 ;
25384 PyObject * obj0 = 0 ;
25385 PyObject * obj1 = 0 ;
25386 PyObject * obj2 = 0 ;
25387 char *kwnames[] = {
25388 (char *) "self",(char *) "pt",(char *) "flags", NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25393 if (SWIG_arg_fail(1)) SWIG_fail;
25394 {
25395 arg2 = &temp2;
25396 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25397 }
25398 if (obj2) {
25399 {
25400 arg3 = (int)(SWIG_As_int(obj2));
25401 if (SWIG_arg_fail(3)) SWIG_fail;
25402 }
25403 }
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 (arg1)->Move((wxPoint const &)*arg2,arg3);
25407
25408 wxPyEndAllowThreads(__tstate);
25409 if (PyErr_Occurred()) SWIG_fail;
25410 }
25411 Py_INCREF(Py_None); resultobj = Py_None;
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25419 PyObject *resultobj;
25420 wxWindow *arg1 = (wxWindow *) 0 ;
25421 int arg2 ;
25422 int arg3 ;
25423 int arg4 = (int) wxSIZE_USE_EXISTING ;
25424 PyObject * obj0 = 0 ;
25425 PyObject * obj1 = 0 ;
25426 PyObject * obj2 = 0 ;
25427 PyObject * obj3 = 0 ;
25428 char *kwnames[] = {
25429 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25430 };
25431
25432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25434 if (SWIG_arg_fail(1)) SWIG_fail;
25435 {
25436 arg2 = (int)(SWIG_As_int(obj1));
25437 if (SWIG_arg_fail(2)) SWIG_fail;
25438 }
25439 {
25440 arg3 = (int)(SWIG_As_int(obj2));
25441 if (SWIG_arg_fail(3)) SWIG_fail;
25442 }
25443 if (obj3) {
25444 {
25445 arg4 = (int)(SWIG_As_int(obj3));
25446 if (SWIG_arg_fail(4)) SWIG_fail;
25447 }
25448 }
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 (arg1)->Move(arg2,arg3,arg4);
25452
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 Py_INCREF(Py_None); resultobj = Py_None;
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj;
25465 wxWindow *arg1 = (wxWindow *) 0 ;
25466 wxSize const &arg2_defvalue = wxDefaultSize ;
25467 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25468 wxSize temp2 ;
25469 PyObject * obj0 = 0 ;
25470 PyObject * obj1 = 0 ;
25471 char *kwnames[] = {
25472 (char *) "self",(char *) "size", NULL
25473 };
25474
25475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25477 if (SWIG_arg_fail(1)) SWIG_fail;
25478 if (obj1) {
25479 {
25480 arg2 = &temp2;
25481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25482 }
25483 }
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25487
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 Py_INCREF(Py_None); resultobj = Py_None;
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj;
25500 wxWindow *arg1 = (wxWindow *) 0 ;
25501 PyObject * obj0 = 0 ;
25502 char *kwnames[] = {
25503 (char *) "self", NULL
25504 };
25505
25506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25508 if (SWIG_arg_fail(1)) SWIG_fail;
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 (arg1)->Raise();
25512
25513 wxPyEndAllowThreads(__tstate);
25514 if (PyErr_Occurred()) SWIG_fail;
25515 }
25516 Py_INCREF(Py_None); resultobj = Py_None;
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj;
25525 wxWindow *arg1 = (wxWindow *) 0 ;
25526 PyObject * obj0 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 (arg1)->Lower();
25537
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 Py_INCREF(Py_None); resultobj = Py_None;
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25549 PyObject *resultobj;
25550 wxWindow *arg1 = (wxWindow *) 0 ;
25551 wxSize *arg2 = 0 ;
25552 wxSize temp2 ;
25553 PyObject * obj0 = 0 ;
25554 PyObject * obj1 = 0 ;
25555 char *kwnames[] = {
25556 (char *) "self",(char *) "size", NULL
25557 };
25558
25559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25561 if (SWIG_arg_fail(1)) SWIG_fail;
25562 {
25563 arg2 = &temp2;
25564 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25565 }
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 (arg1)->SetClientSize((wxSize const &)*arg2);
25569
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 Py_INCREF(Py_None); resultobj = Py_None;
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj;
25582 wxWindow *arg1 = (wxWindow *) 0 ;
25583 int arg2 ;
25584 int arg3 ;
25585 PyObject * obj0 = 0 ;
25586 PyObject * obj1 = 0 ;
25587 PyObject * obj2 = 0 ;
25588 char *kwnames[] = {
25589 (char *) "self",(char *) "width",(char *) "height", NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25594 if (SWIG_arg_fail(1)) SWIG_fail;
25595 {
25596 arg2 = (int)(SWIG_As_int(obj1));
25597 if (SWIG_arg_fail(2)) SWIG_fail;
25598 }
25599 {
25600 arg3 = (int)(SWIG_As_int(obj2));
25601 if (SWIG_arg_fail(3)) SWIG_fail;
25602 }
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 (arg1)->SetClientSize(arg2,arg3);
25606
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 Py_INCREF(Py_None); resultobj = Py_None;
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj;
25619 wxWindow *arg1 = (wxWindow *) 0 ;
25620 wxRect *arg2 = 0 ;
25621 wxRect temp2 ;
25622 PyObject * obj0 = 0 ;
25623 PyObject * obj1 = 0 ;
25624 char *kwnames[] = {
25625 (char *) "self",(char *) "rect", NULL
25626 };
25627
25628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25630 if (SWIG_arg_fail(1)) SWIG_fail;
25631 {
25632 arg2 = &temp2;
25633 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25634 }
25635 {
25636 PyThreadState* __tstate = wxPyBeginAllowThreads();
25637 (arg1)->SetClientSize((wxRect const &)*arg2);
25638
25639 wxPyEndAllowThreads(__tstate);
25640 if (PyErr_Occurred()) SWIG_fail;
25641 }
25642 Py_INCREF(Py_None); resultobj = Py_None;
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25650 PyObject *resultobj;
25651 wxWindow *arg1 = (wxWindow *) 0 ;
25652 wxPoint result;
25653 PyObject * obj0 = 0 ;
25654 char *kwnames[] = {
25655 (char *) "self", NULL
25656 };
25657
25658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25660 if (SWIG_arg_fail(1)) SWIG_fail;
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 result = (arg1)->GetPosition();
25664
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 wxPoint * resultptr;
25670 resultptr = new wxPoint((wxPoint &)(result));
25671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25672 }
25673 return resultobj;
25674 fail:
25675 return NULL;
25676 }
25677
25678
25679 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25680 PyObject *resultobj;
25681 wxWindow *arg1 = (wxWindow *) 0 ;
25682 int *arg2 = (int *) 0 ;
25683 int *arg3 = (int *) 0 ;
25684 int temp2 ;
25685 int res2 = 0 ;
25686 int temp3 ;
25687 int res3 = 0 ;
25688 PyObject * obj0 = 0 ;
25689 char *kwnames[] = {
25690 (char *) "self", NULL
25691 };
25692
25693 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25694 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25697 if (SWIG_arg_fail(1)) SWIG_fail;
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 (arg1)->GetPosition(arg2,arg3);
25701
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 Py_INCREF(Py_None); resultobj = Py_None;
25706 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25707 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25708 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25709 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25710 return resultobj;
25711 fail:
25712 return NULL;
25713 }
25714
25715
25716 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25717 PyObject *resultobj;
25718 wxWindow *arg1 = (wxWindow *) 0 ;
25719 wxSize result;
25720 PyObject * obj0 = 0 ;
25721 char *kwnames[] = {
25722 (char *) "self", NULL
25723 };
25724
25725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25727 if (SWIG_arg_fail(1)) SWIG_fail;
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = ((wxWindow const *)arg1)->GetSize();
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 {
25736 wxSize * resultptr;
25737 resultptr = new wxSize((wxSize &)(result));
25738 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25739 }
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj;
25748 wxWindow *arg1 = (wxWindow *) 0 ;
25749 int *arg2 = (int *) 0 ;
25750 int *arg3 = (int *) 0 ;
25751 int temp2 ;
25752 int res2 = 0 ;
25753 int temp3 ;
25754 int res3 = 0 ;
25755 PyObject * obj0 = 0 ;
25756 char *kwnames[] = {
25757 (char *) "self", NULL
25758 };
25759
25760 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25761 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25764 if (SWIG_arg_fail(1)) SWIG_fail;
25765 {
25766 PyThreadState* __tstate = wxPyBeginAllowThreads();
25767 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25768
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 Py_INCREF(Py_None); resultobj = Py_None;
25773 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25774 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25775 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25776 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj;
25785 wxWindow *arg1 = (wxWindow *) 0 ;
25786 wxRect result;
25787 PyObject * obj0 = 0 ;
25788 char *kwnames[] = {
25789 (char *) "self", NULL
25790 };
25791
25792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25794 if (SWIG_arg_fail(1)) SWIG_fail;
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 result = ((wxWindow const *)arg1)->GetRect();
25798
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 {
25803 wxRect * resultptr;
25804 resultptr = new wxRect((wxRect &)(result));
25805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj;
25815 wxWindow *arg1 = (wxWindow *) 0 ;
25816 wxSize result;
25817 PyObject * obj0 = 0 ;
25818 char *kwnames[] = {
25819 (char *) "self", NULL
25820 };
25821
25822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25824 if (SWIG_arg_fail(1)) SWIG_fail;
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 result = ((wxWindow const *)arg1)->GetClientSize();
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 {
25833 wxSize * resultptr;
25834 resultptr = new wxSize((wxSize &)(result));
25835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25836 }
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj;
25845 wxWindow *arg1 = (wxWindow *) 0 ;
25846 int *arg2 = (int *) 0 ;
25847 int *arg3 = (int *) 0 ;
25848 int temp2 ;
25849 int res2 = 0 ;
25850 int temp3 ;
25851 int res3 = 0 ;
25852 PyObject * obj0 = 0 ;
25853 char *kwnames[] = {
25854 (char *) "self", NULL
25855 };
25856
25857 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25858 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25861 if (SWIG_arg_fail(1)) SWIG_fail;
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25865
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 Py_INCREF(Py_None); resultobj = Py_None;
25870 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25871 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25872 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25873 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj;
25882 wxWindow *arg1 = (wxWindow *) 0 ;
25883 wxPoint result;
25884 PyObject * obj0 = 0 ;
25885 char *kwnames[] = {
25886 (char *) "self", NULL
25887 };
25888
25889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(1)) SWIG_fail;
25892 {
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25895
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 {
25900 wxPoint * resultptr;
25901 resultptr = new wxPoint((wxPoint &)(result));
25902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25903 }
25904 return resultobj;
25905 fail:
25906 return NULL;
25907 }
25908
25909
25910 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25911 PyObject *resultobj;
25912 wxWindow *arg1 = (wxWindow *) 0 ;
25913 wxRect result;
25914 PyObject * obj0 = 0 ;
25915 char *kwnames[] = {
25916 (char *) "self", NULL
25917 };
25918
25919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25921 if (SWIG_arg_fail(1)) SWIG_fail;
25922 {
25923 PyThreadState* __tstate = wxPyBeginAllowThreads();
25924 result = ((wxWindow const *)arg1)->GetClientRect();
25925
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 {
25930 wxRect * resultptr;
25931 resultptr = new wxRect((wxRect &)(result));
25932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25933 }
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25941 PyObject *resultobj;
25942 wxWindow *arg1 = (wxWindow *) 0 ;
25943 wxSize result;
25944 PyObject * obj0 = 0 ;
25945 char *kwnames[] = {
25946 (char *) "self", NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25951 if (SWIG_arg_fail(1)) SWIG_fail;
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = ((wxWindow const *)arg1)->GetBestSize();
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 {
25960 wxSize * resultptr;
25961 resultptr = new wxSize((wxSize &)(result));
25962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25963 }
25964 return resultobj;
25965 fail:
25966 return NULL;
25967 }
25968
25969
25970 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25971 PyObject *resultobj;
25972 wxWindow *arg1 = (wxWindow *) 0 ;
25973 int *arg2 = (int *) 0 ;
25974 int *arg3 = (int *) 0 ;
25975 int temp2 ;
25976 int res2 = 0 ;
25977 int temp3 ;
25978 int res3 = 0 ;
25979 PyObject * obj0 = 0 ;
25980 char *kwnames[] = {
25981 (char *) "self", NULL
25982 };
25983
25984 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25985 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25988 if (SWIG_arg_fail(1)) SWIG_fail;
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25992
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 Py_INCREF(Py_None); resultobj = Py_None;
25997 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25998 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25999 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26000 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26001 return resultobj;
26002 fail:
26003 return NULL;
26004 }
26005
26006
26007 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26008 PyObject *resultobj;
26009 wxWindow *arg1 = (wxWindow *) 0 ;
26010 PyObject * obj0 = 0 ;
26011 char *kwnames[] = {
26012 (char *) "self", NULL
26013 };
26014
26015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26017 if (SWIG_arg_fail(1)) SWIG_fail;
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 (arg1)->InvalidateBestSize();
26021
26022 wxPyEndAllowThreads(__tstate);
26023 if (PyErr_Occurred()) SWIG_fail;
26024 }
26025 Py_INCREF(Py_None); resultobj = Py_None;
26026 return resultobj;
26027 fail:
26028 return NULL;
26029 }
26030
26031
26032 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26033 PyObject *resultobj;
26034 wxWindow *arg1 = (wxWindow *) 0 ;
26035 wxSize result;
26036 PyObject * obj0 = 0 ;
26037 char *kwnames[] = {
26038 (char *) "self", NULL
26039 };
26040
26041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26043 if (SWIG_arg_fail(1)) SWIG_fail;
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26047
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 {
26052 wxSize * resultptr;
26053 resultptr = new wxSize((wxSize &)(result));
26054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26055 }
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj;
26064 wxWindow *arg1 = (wxWindow *) 0 ;
26065 wxSize result;
26066 PyObject * obj0 = 0 ;
26067 char *kwnames[] = {
26068 (char *) "self", NULL
26069 };
26070
26071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26077
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 {
26082 wxSize * resultptr;
26083 resultptr = new wxSize((wxSize &)(result));
26084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj;
26094 wxWindow *arg1 = (wxWindow *) 0 ;
26095 int arg2 = (int) wxBOTH ;
26096 PyObject * obj0 = 0 ;
26097 PyObject * obj1 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self",(char *) "direction", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 if (obj1) {
26106 {
26107 arg2 = (int)(SWIG_As_int(obj1));
26108 if (SWIG_arg_fail(2)) SWIG_fail;
26109 }
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 (arg1)->Center(arg2);
26114
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 Py_INCREF(Py_None); resultobj = Py_None;
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj;
26127 wxWindow *arg1 = (wxWindow *) 0 ;
26128 int arg2 = (int) wxBOTH ;
26129 PyObject * obj0 = 0 ;
26130 PyObject * obj1 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self",(char *) "dir", NULL
26133 };
26134
26135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26137 if (SWIG_arg_fail(1)) SWIG_fail;
26138 if (obj1) {
26139 {
26140 arg2 = (int)(SWIG_As_int(obj1));
26141 if (SWIG_arg_fail(2)) SWIG_fail;
26142 }
26143 }
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 (arg1)->CenterOnScreen(arg2);
26147
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 Py_INCREF(Py_None); resultobj = Py_None;
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj;
26160 wxWindow *arg1 = (wxWindow *) 0 ;
26161 int arg2 = (int) wxBOTH ;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char *kwnames[] = {
26165 (char *) "self",(char *) "dir", NULL
26166 };
26167
26168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26170 if (SWIG_arg_fail(1)) SWIG_fail;
26171 if (obj1) {
26172 {
26173 arg2 = (int)(SWIG_As_int(obj1));
26174 if (SWIG_arg_fail(2)) SWIG_fail;
26175 }
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 (arg1)->CenterOnParent(arg2);
26180
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 Py_INCREF(Py_None); resultobj = Py_None;
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj;
26193 wxWindow *arg1 = (wxWindow *) 0 ;
26194 PyObject * obj0 = 0 ;
26195 char *kwnames[] = {
26196 (char *) "self", NULL
26197 };
26198
26199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26201 if (SWIG_arg_fail(1)) SWIG_fail;
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 (arg1)->Fit();
26205
26206 wxPyEndAllowThreads(__tstate);
26207 if (PyErr_Occurred()) SWIG_fail;
26208 }
26209 Py_INCREF(Py_None); resultobj = Py_None;
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 wxWindow *arg1 = (wxWindow *) 0 ;
26219 PyObject * obj0 = 0 ;
26220 char *kwnames[] = {
26221 (char *) "self", NULL
26222 };
26223
26224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26226 if (SWIG_arg_fail(1)) SWIG_fail;
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 (arg1)->FitInside();
26230
26231 wxPyEndAllowThreads(__tstate);
26232 if (PyErr_Occurred()) SWIG_fail;
26233 }
26234 Py_INCREF(Py_None); resultobj = Py_None;
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26242 PyObject *resultobj;
26243 wxWindow *arg1 = (wxWindow *) 0 ;
26244 int arg2 ;
26245 int arg3 ;
26246 int arg4 = (int) -1 ;
26247 int arg5 = (int) -1 ;
26248 int arg6 = (int) -1 ;
26249 int arg7 = (int) -1 ;
26250 PyObject * obj0 = 0 ;
26251 PyObject * obj1 = 0 ;
26252 PyObject * obj2 = 0 ;
26253 PyObject * obj3 = 0 ;
26254 PyObject * obj4 = 0 ;
26255 PyObject * obj5 = 0 ;
26256 PyObject * obj6 = 0 ;
26257 char *kwnames[] = {
26258 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26259 };
26260
26261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26263 if (SWIG_arg_fail(1)) SWIG_fail;
26264 {
26265 arg2 = (int)(SWIG_As_int(obj1));
26266 if (SWIG_arg_fail(2)) SWIG_fail;
26267 }
26268 {
26269 arg3 = (int)(SWIG_As_int(obj2));
26270 if (SWIG_arg_fail(3)) SWIG_fail;
26271 }
26272 if (obj3) {
26273 {
26274 arg4 = (int)(SWIG_As_int(obj3));
26275 if (SWIG_arg_fail(4)) SWIG_fail;
26276 }
26277 }
26278 if (obj4) {
26279 {
26280 arg5 = (int)(SWIG_As_int(obj4));
26281 if (SWIG_arg_fail(5)) SWIG_fail;
26282 }
26283 }
26284 if (obj5) {
26285 {
26286 arg6 = (int)(SWIG_As_int(obj5));
26287 if (SWIG_arg_fail(6)) SWIG_fail;
26288 }
26289 }
26290 if (obj6) {
26291 {
26292 arg7 = (int)(SWIG_As_int(obj6));
26293 if (SWIG_arg_fail(7)) SWIG_fail;
26294 }
26295 }
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26299
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 Py_INCREF(Py_None); resultobj = Py_None;
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj;
26312 wxWindow *arg1 = (wxWindow *) 0 ;
26313 wxSize *arg2 = 0 ;
26314 wxSize const &arg3_defvalue = wxDefaultSize ;
26315 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26316 wxSize const &arg4_defvalue = wxDefaultSize ;
26317 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26318 wxSize temp2 ;
26319 wxSize temp3 ;
26320 wxSize temp4 ;
26321 PyObject * obj0 = 0 ;
26322 PyObject * obj1 = 0 ;
26323 PyObject * obj2 = 0 ;
26324 PyObject * obj3 = 0 ;
26325 char *kwnames[] = {
26326 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26327 };
26328
26329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26331 if (SWIG_arg_fail(1)) SWIG_fail;
26332 {
26333 arg2 = &temp2;
26334 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26335 }
26336 if (obj2) {
26337 {
26338 arg3 = &temp3;
26339 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26340 }
26341 }
26342 if (obj3) {
26343 {
26344 arg4 = &temp4;
26345 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26346 }
26347 }
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26351
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 Py_INCREF(Py_None); resultobj = Py_None;
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj;
26364 wxWindow *arg1 = (wxWindow *) 0 ;
26365 int arg2 ;
26366 int arg3 ;
26367 int arg4 = (int) -1 ;
26368 int arg5 = (int) -1 ;
26369 PyObject * obj0 = 0 ;
26370 PyObject * obj1 = 0 ;
26371 PyObject * obj2 = 0 ;
26372 PyObject * obj3 = 0 ;
26373 PyObject * obj4 = 0 ;
26374 char *kwnames[] = {
26375 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26376 };
26377
26378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26380 if (SWIG_arg_fail(1)) SWIG_fail;
26381 {
26382 arg2 = (int)(SWIG_As_int(obj1));
26383 if (SWIG_arg_fail(2)) SWIG_fail;
26384 }
26385 {
26386 arg3 = (int)(SWIG_As_int(obj2));
26387 if (SWIG_arg_fail(3)) SWIG_fail;
26388 }
26389 if (obj3) {
26390 {
26391 arg4 = (int)(SWIG_As_int(obj3));
26392 if (SWIG_arg_fail(4)) SWIG_fail;
26393 }
26394 }
26395 if (obj4) {
26396 {
26397 arg5 = (int)(SWIG_As_int(obj4));
26398 if (SWIG_arg_fail(5)) SWIG_fail;
26399 }
26400 }
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26404
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 Py_INCREF(Py_None); resultobj = Py_None;
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 wxWindow *arg1 = (wxWindow *) 0 ;
26418 wxSize *arg2 = 0 ;
26419 wxSize const &arg3_defvalue = wxDefaultSize ;
26420 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26421 wxSize temp2 ;
26422 wxSize temp3 ;
26423 PyObject * obj0 = 0 ;
26424 PyObject * obj1 = 0 ;
26425 PyObject * obj2 = 0 ;
26426 char *kwnames[] = {
26427 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26428 };
26429
26430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26432 if (SWIG_arg_fail(1)) SWIG_fail;
26433 {
26434 arg2 = &temp2;
26435 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26436 }
26437 if (obj2) {
26438 {
26439 arg3 = &temp3;
26440 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 Py_INCREF(Py_None); resultobj = Py_None;
26451 return resultobj;
26452 fail:
26453 return NULL;
26454 }
26455
26456
26457 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26458 PyObject *resultobj;
26459 wxWindow *arg1 = (wxWindow *) 0 ;
26460 wxSize result;
26461 PyObject * obj0 = 0 ;
26462 char *kwnames[] = {
26463 (char *) "self", NULL
26464 };
26465
26466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = ((wxWindow const *)arg1)->GetMaxSize();
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 {
26477 wxSize * resultptr;
26478 resultptr = new wxSize((wxSize &)(result));
26479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26480 }
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj;
26489 wxWindow *arg1 = (wxWindow *) 0 ;
26490 wxSize result;
26491 PyObject * obj0 = 0 ;
26492 char *kwnames[] = {
26493 (char *) "self", NULL
26494 };
26495
26496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26498 if (SWIG_arg_fail(1)) SWIG_fail;
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = ((wxWindow const *)arg1)->GetMinSize();
26502
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 {
26507 wxSize * resultptr;
26508 resultptr = new wxSize((wxSize &)(result));
26509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26510 }
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj;
26519 wxWindow *arg1 = (wxWindow *) 0 ;
26520 wxSize *arg2 = 0 ;
26521 wxSize temp2 ;
26522 PyObject * obj0 = 0 ;
26523 PyObject * obj1 = 0 ;
26524 char *kwnames[] = {
26525 (char *) "self",(char *) "minSize", NULL
26526 };
26527
26528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26530 if (SWIG_arg_fail(1)) SWIG_fail;
26531 {
26532 arg2 = &temp2;
26533 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 (arg1)->SetMinSize((wxSize const &)*arg2);
26538
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 Py_INCREF(Py_None); resultobj = Py_None;
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26550 PyObject *resultobj;
26551 wxWindow *arg1 = (wxWindow *) 0 ;
26552 wxSize *arg2 = 0 ;
26553 wxSize temp2 ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 char *kwnames[] = {
26557 (char *) "self",(char *) "maxSize", NULL
26558 };
26559
26560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26562 if (SWIG_arg_fail(1)) SWIG_fail;
26563 {
26564 arg2 = &temp2;
26565 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 (arg1)->SetMaxSize((wxSize const &)*arg2);
26570
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 Py_INCREF(Py_None); resultobj = Py_None;
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26582 PyObject *resultobj;
26583 wxWindow *arg1 = (wxWindow *) 0 ;
26584 int result;
26585 PyObject * obj0 = 0 ;
26586 char *kwnames[] = {
26587 (char *) "self", NULL
26588 };
26589
26590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26592 if (SWIG_arg_fail(1)) SWIG_fail;
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 {
26601 resultobj = SWIG_From_int((int)(result));
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj;
26611 wxWindow *arg1 = (wxWindow *) 0 ;
26612 int result;
26613 PyObject * obj0 = 0 ;
26614 char *kwnames[] = {
26615 (char *) "self", NULL
26616 };
26617
26618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26620 if (SWIG_arg_fail(1)) SWIG_fail;
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26624
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 {
26629 resultobj = SWIG_From_int((int)(result));
26630 }
26631 return resultobj;
26632 fail:
26633 return NULL;
26634 }
26635
26636
26637 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26638 PyObject *resultobj;
26639 wxWindow *arg1 = (wxWindow *) 0 ;
26640 int result;
26641 PyObject * obj0 = 0 ;
26642 char *kwnames[] = {
26643 (char *) "self", NULL
26644 };
26645
26646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26648 if (SWIG_arg_fail(1)) SWIG_fail;
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26652
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 {
26657 resultobj = SWIG_From_int((int)(result));
26658 }
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26666 PyObject *resultobj;
26667 wxWindow *arg1 = (wxWindow *) 0 ;
26668 int result;
26669 PyObject * obj0 = 0 ;
26670 char *kwnames[] = {
26671 (char *) "self", NULL
26672 };
26673
26674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26676 if (SWIG_arg_fail(1)) SWIG_fail;
26677 {
26678 PyThreadState* __tstate = wxPyBeginAllowThreads();
26679 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26680
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 {
26685 resultobj = SWIG_From_int((int)(result));
26686 }
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj;
26695 wxWindow *arg1 = (wxWindow *) 0 ;
26696 wxSize *arg2 = 0 ;
26697 wxSize temp2 ;
26698 PyObject * obj0 = 0 ;
26699 PyObject * obj1 = 0 ;
26700 char *kwnames[] = {
26701 (char *) "self",(char *) "size", NULL
26702 };
26703
26704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 arg2 = &temp2;
26709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26714
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 Py_INCREF(Py_None); resultobj = Py_None;
26719 return resultobj;
26720 fail:
26721 return NULL;
26722 }
26723
26724
26725 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26726 PyObject *resultobj;
26727 wxWindow *arg1 = (wxWindow *) 0 ;
26728 int arg2 ;
26729 int arg3 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 PyObject * obj2 = 0 ;
26733 char *kwnames[] = {
26734 (char *) "self",(char *) "w",(char *) "h", NULL
26735 };
26736
26737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26739 if (SWIG_arg_fail(1)) SWIG_fail;
26740 {
26741 arg2 = (int)(SWIG_As_int(obj1));
26742 if (SWIG_arg_fail(2)) SWIG_fail;
26743 }
26744 {
26745 arg3 = (int)(SWIG_As_int(obj2));
26746 if (SWIG_arg_fail(3)) SWIG_fail;
26747 }
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 (arg1)->SetVirtualSize(arg2,arg3);
26751
26752 wxPyEndAllowThreads(__tstate);
26753 if (PyErr_Occurred()) SWIG_fail;
26754 }
26755 Py_INCREF(Py_None); resultobj = Py_None;
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26763 PyObject *resultobj;
26764 wxWindow *arg1 = (wxWindow *) 0 ;
26765 wxSize result;
26766 PyObject * obj0 = 0 ;
26767 char *kwnames[] = {
26768 (char *) "self", NULL
26769 };
26770
26771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26773 if (SWIG_arg_fail(1)) SWIG_fail;
26774 {
26775 PyThreadState* __tstate = wxPyBeginAllowThreads();
26776 result = ((wxWindow const *)arg1)->GetVirtualSize();
26777
26778 wxPyEndAllowThreads(__tstate);
26779 if (PyErr_Occurred()) SWIG_fail;
26780 }
26781 {
26782 wxSize * resultptr;
26783 resultptr = new wxSize((wxSize &)(result));
26784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj;
26794 wxWindow *arg1 = (wxWindow *) 0 ;
26795 int *arg2 = (int *) 0 ;
26796 int *arg3 = (int *) 0 ;
26797 int temp2 ;
26798 int res2 = 0 ;
26799 int temp3 ;
26800 int res3 = 0 ;
26801 PyObject * obj0 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self", NULL
26804 };
26805
26806 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26807 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26810 if (SWIG_arg_fail(1)) SWIG_fail;
26811 {
26812 PyThreadState* __tstate = wxPyBeginAllowThreads();
26813 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26814
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 Py_INCREF(Py_None); resultobj = Py_None;
26819 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26820 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26821 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26822 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj;
26831 wxWindow *arg1 = (wxWindow *) 0 ;
26832 wxSize result;
26833 PyObject * obj0 = 0 ;
26834 char *kwnames[] = {
26835 (char *) "self", NULL
26836 };
26837
26838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26840 if (SWIG_arg_fail(1)) SWIG_fail;
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26844
26845 wxPyEndAllowThreads(__tstate);
26846 if (PyErr_Occurred()) SWIG_fail;
26847 }
26848 {
26849 wxSize * resultptr;
26850 resultptr = new wxSize((wxSize &)(result));
26851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 bool arg2 = (bool) true ;
26863 bool result;
26864 PyObject * obj0 = 0 ;
26865 PyObject * obj1 = 0 ;
26866 char *kwnames[] = {
26867 (char *) "self",(char *) "show", NULL
26868 };
26869
26870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26872 if (SWIG_arg_fail(1)) SWIG_fail;
26873 if (obj1) {
26874 {
26875 arg2 = (bool)(SWIG_As_bool(obj1));
26876 if (SWIG_arg_fail(2)) SWIG_fail;
26877 }
26878 }
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = (bool)(arg1)->Show(arg2);
26882
26883 wxPyEndAllowThreads(__tstate);
26884 if (PyErr_Occurred()) SWIG_fail;
26885 }
26886 {
26887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26888 }
26889 return resultobj;
26890 fail:
26891 return NULL;
26892 }
26893
26894
26895 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26896 PyObject *resultobj;
26897 wxWindow *arg1 = (wxWindow *) 0 ;
26898 bool result;
26899 PyObject * obj0 = 0 ;
26900 char *kwnames[] = {
26901 (char *) "self", NULL
26902 };
26903
26904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26906 if (SWIG_arg_fail(1)) SWIG_fail;
26907 {
26908 PyThreadState* __tstate = wxPyBeginAllowThreads();
26909 result = (bool)(arg1)->Hide();
26910
26911 wxPyEndAllowThreads(__tstate);
26912 if (PyErr_Occurred()) SWIG_fail;
26913 }
26914 {
26915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26916 }
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxWindow *arg1 = (wxWindow *) 0 ;
26926 bool arg2 = (bool) true ;
26927 bool result;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self",(char *) "enable", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 if (obj1) {
26938 {
26939 arg2 = (bool)(SWIG_As_bool(obj1));
26940 if (SWIG_arg_fail(2)) SWIG_fail;
26941 }
26942 }
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 result = (bool)(arg1)->Enable(arg2);
26946
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxWindow *arg1 = (wxWindow *) 0 ;
26962 bool result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = (bool)(arg1)->Disable();
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 {
26979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26980 }
26981 return resultobj;
26982 fail:
26983 return NULL;
26984 }
26985
26986
26987 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26988 PyObject *resultobj;
26989 wxWindow *arg1 = (wxWindow *) 0 ;
26990 bool result;
26991 PyObject * obj0 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self", NULL
26994 };
26995
26996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26998 if (SWIG_arg_fail(1)) SWIG_fail;
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 result = (bool)((wxWindow const *)arg1)->IsShown();
27002
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27008 }
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27016 PyObject *resultobj;
27017 wxWindow *arg1 = (wxWindow *) 0 ;
27018 bool result;
27019 PyObject * obj0 = 0 ;
27020 char *kwnames[] = {
27021 (char *) "self", NULL
27022 };
27023
27024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27026 if (SWIG_arg_fail(1)) SWIG_fail;
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27030
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 {
27035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27036 }
27037 return resultobj;
27038 fail:
27039 return NULL;
27040 }
27041
27042
27043 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj;
27045 wxWindow *arg1 = (wxWindow *) 0 ;
27046 long arg2 ;
27047 PyObject * obj0 = 0 ;
27048 PyObject * obj1 = 0 ;
27049 char *kwnames[] = {
27050 (char *) "self",(char *) "style", NULL
27051 };
27052
27053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27055 if (SWIG_arg_fail(1)) SWIG_fail;
27056 {
27057 arg2 = (long)(SWIG_As_long(obj1));
27058 if (SWIG_arg_fail(2)) SWIG_fail;
27059 }
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 (arg1)->SetWindowStyleFlag(arg2);
27063
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 Py_INCREF(Py_None); resultobj = Py_None;
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj;
27076 wxWindow *arg1 = (wxWindow *) 0 ;
27077 long result;
27078 PyObject * obj0 = 0 ;
27079 char *kwnames[] = {
27080 (char *) "self", NULL
27081 };
27082
27083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27085 if (SWIG_arg_fail(1)) SWIG_fail;
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27089
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 {
27094 resultobj = SWIG_From_long((long)(result));
27095 }
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27103 PyObject *resultobj;
27104 wxWindow *arg1 = (wxWindow *) 0 ;
27105 int arg2 ;
27106 bool result;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char *kwnames[] = {
27110 (char *) "self",(char *) "flag", NULL
27111 };
27112
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 {
27117 arg2 = (int)(SWIG_As_int(obj1));
27118 if (SWIG_arg_fail(2)) SWIG_fail;
27119 }
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27123
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj;
27138 wxWindow *arg1 = (wxWindow *) 0 ;
27139 bool result;
27140 PyObject * obj0 = 0 ;
27141 char *kwnames[] = {
27142 (char *) "self", NULL
27143 };
27144
27145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27147 if (SWIG_arg_fail(1)) SWIG_fail;
27148 {
27149 PyThreadState* __tstate = wxPyBeginAllowThreads();
27150 result = (bool)((wxWindow const *)arg1)->IsRetained();
27151
27152 wxPyEndAllowThreads(__tstate);
27153 if (PyErr_Occurred()) SWIG_fail;
27154 }
27155 {
27156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27157 }
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj;
27166 wxWindow *arg1 = (wxWindow *) 0 ;
27167 long arg2 ;
27168 PyObject * obj0 = 0 ;
27169 PyObject * obj1 = 0 ;
27170 char *kwnames[] = {
27171 (char *) "self",(char *) "exStyle", NULL
27172 };
27173
27174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27176 if (SWIG_arg_fail(1)) SWIG_fail;
27177 {
27178 arg2 = (long)(SWIG_As_long(obj1));
27179 if (SWIG_arg_fail(2)) SWIG_fail;
27180 }
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 (arg1)->SetExtraStyle(arg2);
27184
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 Py_INCREF(Py_None); resultobj = Py_None;
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj;
27197 wxWindow *arg1 = (wxWindow *) 0 ;
27198 long result;
27199 PyObject * obj0 = 0 ;
27200 char *kwnames[] = {
27201 (char *) "self", NULL
27202 };
27203
27204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27206 if (SWIG_arg_fail(1)) SWIG_fail;
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27210
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 {
27215 resultobj = SWIG_From_long((long)(result));
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj;
27225 wxWindow *arg1 = (wxWindow *) 0 ;
27226 bool arg2 = (bool) true ;
27227 PyObject * obj0 = 0 ;
27228 PyObject * obj1 = 0 ;
27229 char *kwnames[] = {
27230 (char *) "self",(char *) "modal", NULL
27231 };
27232
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 if (obj1) {
27237 {
27238 arg2 = (bool)(SWIG_As_bool(obj1));
27239 if (SWIG_arg_fail(2)) SWIG_fail;
27240 }
27241 }
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 (arg1)->MakeModal(arg2);
27245
27246 wxPyEndAllowThreads(__tstate);
27247 if (PyErr_Occurred()) SWIG_fail;
27248 }
27249 Py_INCREF(Py_None); resultobj = Py_None;
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxWindow *arg1 = (wxWindow *) 0 ;
27259 bool arg2 ;
27260 PyObject * obj0 = 0 ;
27261 PyObject * obj1 = 0 ;
27262 char *kwnames[] = {
27263 (char *) "self",(char *) "enableTheme", NULL
27264 };
27265
27266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27268 if (SWIG_arg_fail(1)) SWIG_fail;
27269 {
27270 arg2 = (bool)(SWIG_As_bool(obj1));
27271 if (SWIG_arg_fail(2)) SWIG_fail;
27272 }
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->SetThemeEnabled(arg2);
27276
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 Py_INCREF(Py_None); resultobj = Py_None;
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj;
27289 wxWindow *arg1 = (wxWindow *) 0 ;
27290 bool result;
27291 PyObject * obj0 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27302
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 {
27307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj;
27317 wxWindow *arg1 = (wxWindow *) 0 ;
27318 PyObject * obj0 = 0 ;
27319 char *kwnames[] = {
27320 (char *) "self", NULL
27321 };
27322
27323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27325 if (SWIG_arg_fail(1)) SWIG_fail;
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 (arg1)->SetFocus();
27329
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 Py_INCREF(Py_None); resultobj = Py_None;
27334 return resultobj;
27335 fail:
27336 return NULL;
27337 }
27338
27339
27340 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27341 PyObject *resultobj;
27342 wxWindow *arg1 = (wxWindow *) 0 ;
27343 PyObject * obj0 = 0 ;
27344 char *kwnames[] = {
27345 (char *) "self", NULL
27346 };
27347
27348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27350 if (SWIG_arg_fail(1)) SWIG_fail;
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 (arg1)->SetFocusFromKbd();
27354
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 Py_INCREF(Py_None); resultobj = Py_None;
27359 return resultobj;
27360 fail:
27361 return NULL;
27362 }
27363
27364
27365 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27366 PyObject *resultobj;
27367 wxWindow *result;
27368 char *kwnames[] = {
27369 NULL
27370 };
27371
27372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27373 {
27374 if (!wxPyCheckForApp()) SWIG_fail;
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 result = (wxWindow *)wxWindow::FindFocus();
27377
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 {
27382 resultobj = wxPyMake_wxObject(result, 0);
27383 }
27384 return resultobj;
27385 fail:
27386 return NULL;
27387 }
27388
27389
27390 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj;
27392 wxWindow *arg1 = (wxWindow *) 0 ;
27393 bool result;
27394 PyObject * obj0 = 0 ;
27395 char *kwnames[] = {
27396 (char *) "self", NULL
27397 };
27398
27399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27401 if (SWIG_arg_fail(1)) SWIG_fail;
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27405
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 {
27410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27411 }
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj;
27420 wxWindow *arg1 = (wxWindow *) 0 ;
27421 bool result;
27422 PyObject * obj0 = 0 ;
27423 char *kwnames[] = {
27424 (char *) "self", NULL
27425 };
27426
27427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27429 if (SWIG_arg_fail(1)) SWIG_fail;
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27433
27434 wxPyEndAllowThreads(__tstate);
27435 if (PyErr_Occurred()) SWIG_fail;
27436 }
27437 {
27438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27439 }
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj;
27448 wxWindow *arg1 = (wxWindow *) 0 ;
27449 wxWindow *result;
27450 PyObject * obj0 = 0 ;
27451 char *kwnames[] = {
27452 (char *) "self", NULL
27453 };
27454
27455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27457 if (SWIG_arg_fail(1)) SWIG_fail;
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = wxPyMake_wxObject(result, 0);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxWindow *arg1 = (wxWindow *) 0 ;
27477 wxWindow *arg2 = (wxWindow *) 0 ;
27478 wxWindow *result;
27479 PyObject * obj0 = 0 ;
27480 PyObject * obj1 = 0 ;
27481 char *kwnames[] = {
27482 (char *) "self",(char *) "child", NULL
27483 };
27484
27485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27487 if (SWIG_arg_fail(1)) SWIG_fail;
27488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27489 if (SWIG_arg_fail(2)) SWIG_fail;
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27493
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 {
27498 resultobj = wxPyMake_wxObject(result, 0);
27499 }
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27507 PyObject *resultobj;
27508 wxWindow *arg1 = (wxWindow *) 0 ;
27509 wxWindow *arg2 = (wxWindow *) 0 ;
27510 PyObject * obj0 = 0 ;
27511 PyObject * obj1 = 0 ;
27512 char *kwnames[] = {
27513 (char *) "self",(char *) "win", NULL
27514 };
27515
27516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27518 if (SWIG_arg_fail(1)) SWIG_fail;
27519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27520 if (SWIG_arg_fail(2)) SWIG_fail;
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 (arg1)->SetTmpDefaultItem(arg2);
27524
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 Py_INCREF(Py_None); resultobj = Py_None;
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj;
27537 wxWindow *arg1 = (wxWindow *) 0 ;
27538 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27539 bool result;
27540 PyObject * obj0 = 0 ;
27541 PyObject * obj1 = 0 ;
27542 char *kwnames[] = {
27543 (char *) "self",(char *) "flags", NULL
27544 };
27545
27546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(1)) SWIG_fail;
27549 if (obj1) {
27550 {
27551 arg2 = (int)(SWIG_As_int(obj1));
27552 if (SWIG_arg_fail(2)) SWIG_fail;
27553 }
27554 }
27555 {
27556 PyThreadState* __tstate = wxPyBeginAllowThreads();
27557 result = (bool)(arg1)->Navigate(arg2);
27558
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj;
27573 wxWindow *arg1 = (wxWindow *) 0 ;
27574 wxWindow *arg2 = (wxWindow *) 0 ;
27575 PyObject * obj0 = 0 ;
27576 PyObject * obj1 = 0 ;
27577 char *kwnames[] = {
27578 (char *) "self",(char *) "win", NULL
27579 };
27580
27581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27583 if (SWIG_arg_fail(1)) SWIG_fail;
27584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(2)) SWIG_fail;
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 (arg1)->MoveAfterInTabOrder(arg2);
27589
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 Py_INCREF(Py_None); resultobj = Py_None;
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxWindow *arg1 = (wxWindow *) 0 ;
27603 wxWindow *arg2 = (wxWindow *) 0 ;
27604 PyObject * obj0 = 0 ;
27605 PyObject * obj1 = 0 ;
27606 char *kwnames[] = {
27607 (char *) "self",(char *) "win", NULL
27608 };
27609
27610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27612 if (SWIG_arg_fail(1)) SWIG_fail;
27613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(2)) SWIG_fail;
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 (arg1)->MoveBeforeInTabOrder(arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 Py_INCREF(Py_None); resultobj = Py_None;
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxWindow *arg1 = (wxWindow *) 0 ;
27632 PyObject *result;
27633 PyObject * obj0 = 0 ;
27634 char *kwnames[] = {
27635 (char *) "self", NULL
27636 };
27637
27638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27640 if (SWIG_arg_fail(1)) SWIG_fail;
27641 {
27642 PyThreadState* __tstate = wxPyBeginAllowThreads();
27643 result = (PyObject *)wxWindow_GetChildren(arg1);
27644
27645 wxPyEndAllowThreads(__tstate);
27646 if (PyErr_Occurred()) SWIG_fail;
27647 }
27648 resultobj = result;
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27656 PyObject *resultobj;
27657 wxWindow *arg1 = (wxWindow *) 0 ;
27658 wxWindow *result;
27659 PyObject * obj0 = 0 ;
27660 char *kwnames[] = {
27661 (char *) "self", NULL
27662 };
27663
27664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27666 if (SWIG_arg_fail(1)) SWIG_fail;
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27670
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 {
27675 resultobj = wxPyMake_wxObject(result, 0);
27676 }
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj;
27685 wxWindow *arg1 = (wxWindow *) 0 ;
27686 wxWindow *result;
27687 PyObject * obj0 = 0 ;
27688 char *kwnames[] = {
27689 (char *) "self", NULL
27690 };
27691
27692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27694 if (SWIG_arg_fail(1)) SWIG_fail;
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 {
27703 resultobj = wxPyMake_wxObject(result, 0);
27704 }
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj;
27713 wxWindow *arg1 = (wxWindow *) 0 ;
27714 bool result;
27715 PyObject * obj0 = 0 ;
27716 char *kwnames[] = {
27717 (char *) "self", NULL
27718 };
27719
27720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27722 if (SWIG_arg_fail(1)) SWIG_fail;
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27726
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 {
27731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27732 }
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27740 PyObject *resultobj;
27741 wxWindow *arg1 = (wxWindow *) 0 ;
27742 wxWindow *arg2 = (wxWindow *) 0 ;
27743 bool result;
27744 PyObject * obj0 = 0 ;
27745 PyObject * obj1 = 0 ;
27746 char *kwnames[] = {
27747 (char *) "self",(char *) "newParent", NULL
27748 };
27749
27750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27752 if (SWIG_arg_fail(1)) SWIG_fail;
27753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27754 if (SWIG_arg_fail(2)) SWIG_fail;
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 result = (bool)(arg1)->Reparent(arg2);
27758
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 {
27763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27764 }
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxWindow *arg1 = (wxWindow *) 0 ;
27774 wxWindow *arg2 = (wxWindow *) 0 ;
27775 PyObject * obj0 = 0 ;
27776 PyObject * obj1 = 0 ;
27777 char *kwnames[] = {
27778 (char *) "self",(char *) "child", NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27785 if (SWIG_arg_fail(2)) SWIG_fail;
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->AddChild(arg2);
27789
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 Py_INCREF(Py_None); resultobj = Py_None;
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj;
27802 wxWindow *arg1 = (wxWindow *) 0 ;
27803 wxWindow *arg2 = (wxWindow *) 0 ;
27804 PyObject * obj0 = 0 ;
27805 PyObject * obj1 = 0 ;
27806 char *kwnames[] = {
27807 (char *) "self",(char *) "child", NULL
27808 };
27809
27810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(1)) SWIG_fail;
27813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27814 if (SWIG_arg_fail(2)) SWIG_fail;
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 (arg1)->RemoveChild(arg2);
27818
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 Py_INCREF(Py_None); resultobj = Py_None;
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj;
27831 wxWindow *arg1 = (wxWindow *) 0 ;
27832 long arg2 ;
27833 wxWindow *result;
27834 PyObject * obj0 = 0 ;
27835 PyObject * obj1 = 0 ;
27836 char *kwnames[] = {
27837 (char *) "self",(char *) "winid", NULL
27838 };
27839
27840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27842 if (SWIG_arg_fail(1)) SWIG_fail;
27843 {
27844 arg2 = (long)(SWIG_As_long(obj1));
27845 if (SWIG_arg_fail(2)) SWIG_fail;
27846 }
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (wxWindow *)(arg1)->FindWindow(arg2);
27850
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 resultobj = wxPyMake_wxObject(result, 0);
27856 }
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj;
27865 wxWindow *arg1 = (wxWindow *) 0 ;
27866 wxString *arg2 = 0 ;
27867 wxWindow *result;
27868 bool temp2 = false ;
27869 PyObject * obj0 = 0 ;
27870 PyObject * obj1 = 0 ;
27871 char *kwnames[] = {
27872 (char *) "self",(char *) "name", NULL
27873 };
27874
27875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27877 if (SWIG_arg_fail(1)) SWIG_fail;
27878 {
27879 arg2 = wxString_in_helper(obj1);
27880 if (arg2 == NULL) SWIG_fail;
27881 temp2 = true;
27882 }
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27886
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = wxPyMake_wxObject(result, 0);
27892 }
27893 {
27894 if (temp2)
27895 delete arg2;
27896 }
27897 return resultobj;
27898 fail:
27899 {
27900 if (temp2)
27901 delete arg2;
27902 }
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxWindow *arg1 = (wxWindow *) 0 ;
27910 wxEvtHandler *result;
27911 PyObject * obj0 = 0 ;
27912 char *kwnames[] = {
27913 (char *) "self", NULL
27914 };
27915
27916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27918 if (SWIG_arg_fail(1)) SWIG_fail;
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27922
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 {
27927 resultobj = wxPyMake_wxObject(result, 0);
27928 }
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27936 PyObject *resultobj;
27937 wxWindow *arg1 = (wxWindow *) 0 ;
27938 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27939 PyObject * obj0 = 0 ;
27940 PyObject * obj1 = 0 ;
27941 char *kwnames[] = {
27942 (char *) "self",(char *) "handler", NULL
27943 };
27944
27945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27947 if (SWIG_arg_fail(1)) SWIG_fail;
27948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27949 if (SWIG_arg_fail(2)) SWIG_fail;
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 (arg1)->SetEventHandler(arg2);
27953
27954 wxPyEndAllowThreads(__tstate);
27955 if (PyErr_Occurred()) SWIG_fail;
27956 }
27957 Py_INCREF(Py_None); resultobj = Py_None;
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj;
27966 wxWindow *arg1 = (wxWindow *) 0 ;
27967 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27968 PyObject * obj0 = 0 ;
27969 PyObject * obj1 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self",(char *) "handler", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(2)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 (arg1)->PushEventHandler(arg2);
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 Py_INCREF(Py_None); resultobj = Py_None;
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 bool arg2 = (bool) false ;
27997 wxEvtHandler *result;
27998 PyObject * obj0 = 0 ;
27999 PyObject * obj1 = 0 ;
28000 char *kwnames[] = {
28001 (char *) "self",(char *) "deleteHandler", NULL
28002 };
28003
28004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28006 if (SWIG_arg_fail(1)) SWIG_fail;
28007 if (obj1) {
28008 {
28009 arg2 = (bool)(SWIG_As_bool(obj1));
28010 if (SWIG_arg_fail(2)) SWIG_fail;
28011 }
28012 }
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28016
28017 wxPyEndAllowThreads(__tstate);
28018 if (PyErr_Occurred()) SWIG_fail;
28019 }
28020 {
28021 resultobj = wxPyMake_wxObject(result, 0);
28022 }
28023 return resultobj;
28024 fail:
28025 return NULL;
28026 }
28027
28028
28029 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28030 PyObject *resultobj;
28031 wxWindow *arg1 = (wxWindow *) 0 ;
28032 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28033 bool result;
28034 PyObject * obj0 = 0 ;
28035 PyObject * obj1 = 0 ;
28036 char *kwnames[] = {
28037 (char *) "self",(char *) "handler", NULL
28038 };
28039
28040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28042 if (SWIG_arg_fail(1)) SWIG_fail;
28043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28044 if (SWIG_arg_fail(2)) SWIG_fail;
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 result = (bool)(arg1)->RemoveEventHandler(arg2);
28048
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 {
28053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28054 }
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28062 PyObject *resultobj;
28063 wxWindow *arg1 = (wxWindow *) 0 ;
28064 wxValidator *arg2 = 0 ;
28065 PyObject * obj0 = 0 ;
28066 PyObject * obj1 = 0 ;
28067 char *kwnames[] = {
28068 (char *) "self",(char *) "validator", NULL
28069 };
28070
28071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28073 if (SWIG_arg_fail(1)) SWIG_fail;
28074 {
28075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28076 if (SWIG_arg_fail(2)) SWIG_fail;
28077 if (arg2 == NULL) {
28078 SWIG_null_ref("wxValidator");
28079 }
28080 if (SWIG_arg_fail(2)) SWIG_fail;
28081 }
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 (arg1)->SetValidator((wxValidator const &)*arg2);
28085
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 Py_INCREF(Py_None); resultobj = Py_None;
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj;
28098 wxWindow *arg1 = (wxWindow *) 0 ;
28099 wxValidator *result;
28100 PyObject * obj0 = 0 ;
28101 char *kwnames[] = {
28102 (char *) "self", NULL
28103 };
28104
28105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28107 if (SWIG_arg_fail(1)) SWIG_fail;
28108 {
28109 PyThreadState* __tstate = wxPyBeginAllowThreads();
28110 result = (wxValidator *)(arg1)->GetValidator();
28111
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 {
28116 resultobj = wxPyMake_wxObject(result, 0);
28117 }
28118 return resultobj;
28119 fail:
28120 return NULL;
28121 }
28122
28123
28124 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28125 PyObject *resultobj;
28126 wxWindow *arg1 = (wxWindow *) 0 ;
28127 bool result;
28128 PyObject * obj0 = 0 ;
28129 char *kwnames[] = {
28130 (char *) "self", NULL
28131 };
28132
28133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28135 if (SWIG_arg_fail(1)) SWIG_fail;
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 result = (bool)(arg1)->Validate();
28139
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 {
28144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28145 }
28146 return resultobj;
28147 fail:
28148 return NULL;
28149 }
28150
28151
28152 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28153 PyObject *resultobj;
28154 wxWindow *arg1 = (wxWindow *) 0 ;
28155 bool result;
28156 PyObject * obj0 = 0 ;
28157 char *kwnames[] = {
28158 (char *) "self", NULL
28159 };
28160
28161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28163 if (SWIG_arg_fail(1)) SWIG_fail;
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)(arg1)->TransferDataToWindow();
28167
28168 wxPyEndAllowThreads(__tstate);
28169 if (PyErr_Occurred()) SWIG_fail;
28170 }
28171 {
28172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 bool result;
28184 PyObject * obj0 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 result = (bool)(arg1)->TransferDataFromWindow();
28195
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 {
28200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28201 }
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28209 PyObject *resultobj;
28210 wxWindow *arg1 = (wxWindow *) 0 ;
28211 PyObject * obj0 = 0 ;
28212 char *kwnames[] = {
28213 (char *) "self", NULL
28214 };
28215
28216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28218 if (SWIG_arg_fail(1)) SWIG_fail;
28219 {
28220 PyThreadState* __tstate = wxPyBeginAllowThreads();
28221 (arg1)->InitDialog();
28222
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 Py_INCREF(Py_None); resultobj = Py_None;
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28234 PyObject *resultobj;
28235 wxWindow *arg1 = (wxWindow *) 0 ;
28236 wxAcceleratorTable *arg2 = 0 ;
28237 PyObject * obj0 = 0 ;
28238 PyObject * obj1 = 0 ;
28239 char *kwnames[] = {
28240 (char *) "self",(char *) "accel", NULL
28241 };
28242
28243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28245 if (SWIG_arg_fail(1)) SWIG_fail;
28246 {
28247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28248 if (SWIG_arg_fail(2)) SWIG_fail;
28249 if (arg2 == NULL) {
28250 SWIG_null_ref("wxAcceleratorTable");
28251 }
28252 if (SWIG_arg_fail(2)) SWIG_fail;
28253 }
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28257
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 Py_INCREF(Py_None); resultobj = Py_None;
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj;
28270 wxWindow *arg1 = (wxWindow *) 0 ;
28271 wxAcceleratorTable *result;
28272 PyObject * obj0 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28279 if (SWIG_arg_fail(1)) SWIG_fail;
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28283
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj;
28296 wxWindow *arg1 = (wxWindow *) 0 ;
28297 int arg2 ;
28298 int arg3 ;
28299 int arg4 ;
28300 bool result;
28301 PyObject * obj0 = 0 ;
28302 PyObject * obj1 = 0 ;
28303 PyObject * obj2 = 0 ;
28304 PyObject * obj3 = 0 ;
28305 char *kwnames[] = {
28306 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28307 };
28308
28309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28311 if (SWIG_arg_fail(1)) SWIG_fail;
28312 {
28313 arg2 = (int)(SWIG_As_int(obj1));
28314 if (SWIG_arg_fail(2)) SWIG_fail;
28315 }
28316 {
28317 arg3 = (int)(SWIG_As_int(obj2));
28318 if (SWIG_arg_fail(3)) SWIG_fail;
28319 }
28320 {
28321 arg4 = (int)(SWIG_As_int(obj3));
28322 if (SWIG_arg_fail(4)) SWIG_fail;
28323 }
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28327
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 {
28332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28333 }
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj;
28342 wxWindow *arg1 = (wxWindow *) 0 ;
28343 int arg2 ;
28344 bool result;
28345 PyObject * obj0 = 0 ;
28346 PyObject * obj1 = 0 ;
28347 char *kwnames[] = {
28348 (char *) "self",(char *) "hotkeyId", NULL
28349 };
28350
28351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28353 if (SWIG_arg_fail(1)) SWIG_fail;
28354 {
28355 arg2 = (int)(SWIG_As_int(obj1));
28356 if (SWIG_arg_fail(2)) SWIG_fail;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj;
28376 wxWindow *arg1 = (wxWindow *) 0 ;
28377 wxPoint *arg2 = 0 ;
28378 wxPoint result;
28379 wxPoint temp2 ;
28380 PyObject * obj0 = 0 ;
28381 PyObject * obj1 = 0 ;
28382 char *kwnames[] = {
28383 (char *) "self",(char *) "pt", NULL
28384 };
28385
28386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28388 if (SWIG_arg_fail(1)) SWIG_fail;
28389 {
28390 arg2 = &temp2;
28391 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28392 }
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28396
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 {
28401 wxPoint * resultptr;
28402 resultptr = new wxPoint((wxPoint &)(result));
28403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28404 }
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28412 PyObject *resultobj;
28413 wxWindow *arg1 = (wxWindow *) 0 ;
28414 wxSize *arg2 = 0 ;
28415 wxSize result;
28416 wxSize temp2 ;
28417 PyObject * obj0 = 0 ;
28418 PyObject * obj1 = 0 ;
28419 char *kwnames[] = {
28420 (char *) "self",(char *) "sz", NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28425 if (SWIG_arg_fail(1)) SWIG_fail;
28426 {
28427 arg2 = &temp2;
28428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28429 }
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 wxSize * resultptr;
28439 resultptr = new wxSize((wxSize &)(result));
28440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28441 }
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28449 PyObject *resultobj;
28450 wxWindow *arg1 = (wxWindow *) 0 ;
28451 wxPoint *arg2 = 0 ;
28452 wxPoint result;
28453 wxPoint temp2 ;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char *kwnames[] = {
28457 (char *) "self",(char *) "pt", NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 {
28464 arg2 = &temp2;
28465 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28466 }
28467 {
28468 PyThreadState* __tstate = wxPyBeginAllowThreads();
28469 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28470
28471 wxPyEndAllowThreads(__tstate);
28472 if (PyErr_Occurred()) SWIG_fail;
28473 }
28474 {
28475 wxPoint * resultptr;
28476 resultptr = new wxPoint((wxPoint &)(result));
28477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28478 }
28479 return resultobj;
28480 fail:
28481 return NULL;
28482 }
28483
28484
28485 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28486 PyObject *resultobj;
28487 wxWindow *arg1 = (wxWindow *) 0 ;
28488 wxSize *arg2 = 0 ;
28489 wxSize result;
28490 wxSize temp2 ;
28491 PyObject * obj0 = 0 ;
28492 PyObject * obj1 = 0 ;
28493 char *kwnames[] = {
28494 (char *) "self",(char *) "sz", NULL
28495 };
28496
28497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28499 if (SWIG_arg_fail(1)) SWIG_fail;
28500 {
28501 arg2 = &temp2;
28502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28503 }
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 wxSize * resultptr;
28513 resultptr = new wxSize((wxSize &)(result));
28514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28515 }
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28523 PyObject *resultobj;
28524 wxWindow *arg1 = (wxWindow *) 0 ;
28525 wxPoint *arg2 = 0 ;
28526 wxPoint result;
28527 wxPoint temp2 ;
28528 PyObject * obj0 = 0 ;
28529 PyObject * obj1 = 0 ;
28530 char *kwnames[] = {
28531 (char *) "self",(char *) "pt", NULL
28532 };
28533
28534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28536 if (SWIG_arg_fail(1)) SWIG_fail;
28537 {
28538 arg2 = &temp2;
28539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28540 }
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 wxPoint * resultptr;
28550 resultptr = new wxPoint((wxPoint &)(result));
28551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28552 }
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28560 PyObject *resultobj;
28561 wxWindow *arg1 = (wxWindow *) 0 ;
28562 wxSize *arg2 = 0 ;
28563 wxSize result;
28564 wxSize temp2 ;
28565 PyObject * obj0 = 0 ;
28566 PyObject * obj1 = 0 ;
28567 char *kwnames[] = {
28568 (char *) "self",(char *) "sz", NULL
28569 };
28570
28571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28573 if (SWIG_arg_fail(1)) SWIG_fail;
28574 {
28575 arg2 = &temp2;
28576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28577 }
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28581
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 {
28586 wxSize * resultptr;
28587 resultptr = new wxSize((wxSize &)(result));
28588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28589 }
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28597 PyObject *resultobj;
28598 wxWindow *arg1 = (wxWindow *) 0 ;
28599 int arg2 ;
28600 int arg3 ;
28601 PyObject * obj0 = 0 ;
28602 PyObject * obj1 = 0 ;
28603 PyObject * obj2 = 0 ;
28604 char *kwnames[] = {
28605 (char *) "self",(char *) "x",(char *) "y", NULL
28606 };
28607
28608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28610 if (SWIG_arg_fail(1)) SWIG_fail;
28611 {
28612 arg2 = (int)(SWIG_As_int(obj1));
28613 if (SWIG_arg_fail(2)) SWIG_fail;
28614 }
28615 {
28616 arg3 = (int)(SWIG_As_int(obj2));
28617 if (SWIG_arg_fail(3)) SWIG_fail;
28618 }
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 (arg1)->WarpPointer(arg2,arg3);
28622
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 Py_INCREF(Py_None); resultobj = Py_None;
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj;
28635 wxWindow *arg1 = (wxWindow *) 0 ;
28636 PyObject * obj0 = 0 ;
28637 char *kwnames[] = {
28638 (char *) "self", NULL
28639 };
28640
28641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28643 if (SWIG_arg_fail(1)) SWIG_fail;
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 (arg1)->CaptureMouse();
28647
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 Py_INCREF(Py_None); resultobj = Py_None;
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28659 PyObject *resultobj;
28660 wxWindow *arg1 = (wxWindow *) 0 ;
28661 PyObject * obj0 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "self", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 (arg1)->ReleaseMouse();
28672
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 Py_INCREF(Py_None); resultobj = Py_None;
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28684 PyObject *resultobj;
28685 wxWindow *result;
28686 char *kwnames[] = {
28687 NULL
28688 };
28689
28690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28691 {
28692 if (!wxPyCheckForApp()) SWIG_fail;
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 result = (wxWindow *)wxWindow::GetCapture();
28695
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 {
28700 resultobj = wxPyMake_wxObject(result, 0);
28701 }
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28709 PyObject *resultobj;
28710 wxWindow *arg1 = (wxWindow *) 0 ;
28711 bool result;
28712 PyObject * obj0 = 0 ;
28713 char *kwnames[] = {
28714 (char *) "self", NULL
28715 };
28716
28717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28719 if (SWIG_arg_fail(1)) SWIG_fail;
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 result = (bool)((wxWindow const *)arg1)->HasCapture();
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 {
28728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28729 }
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj;
28738 wxWindow *arg1 = (wxWindow *) 0 ;
28739 bool arg2 = (bool) true ;
28740 wxRect *arg3 = (wxRect *) NULL ;
28741 PyObject * obj0 = 0 ;
28742 PyObject * obj1 = 0 ;
28743 PyObject * obj2 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 if (obj1) {
28752 {
28753 arg2 = (bool)(SWIG_As_bool(obj1));
28754 if (SWIG_arg_fail(2)) SWIG_fail;
28755 }
28756 }
28757 if (obj2) {
28758 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28759 if (SWIG_arg_fail(3)) SWIG_fail;
28760 }
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 Py_INCREF(Py_None); resultobj = Py_None;
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj;
28777 wxWindow *arg1 = (wxWindow *) 0 ;
28778 wxRect *arg2 = 0 ;
28779 bool arg3 = (bool) true ;
28780 wxRect temp2 ;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 PyObject * obj2 = 0 ;
28784 char *kwnames[] = {
28785 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28786 };
28787
28788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28790 if (SWIG_arg_fail(1)) SWIG_fail;
28791 {
28792 arg2 = &temp2;
28793 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28794 }
28795 if (obj2) {
28796 {
28797 arg3 = (bool)(SWIG_As_bool(obj2));
28798 if (SWIG_arg_fail(3)) SWIG_fail;
28799 }
28800 }
28801 {
28802 PyThreadState* __tstate = wxPyBeginAllowThreads();
28803 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28804
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 Py_INCREF(Py_None); resultobj = Py_None;
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj;
28817 wxWindow *arg1 = (wxWindow *) 0 ;
28818 PyObject * obj0 = 0 ;
28819 char *kwnames[] = {
28820 (char *) "self", NULL
28821 };
28822
28823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28825 if (SWIG_arg_fail(1)) SWIG_fail;
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 (arg1)->Update();
28829
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 Py_INCREF(Py_None); resultobj = Py_None;
28834 return resultobj;
28835 fail:
28836 return NULL;
28837 }
28838
28839
28840 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28841 PyObject *resultobj;
28842 wxWindow *arg1 = (wxWindow *) 0 ;
28843 PyObject * obj0 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 (arg1)->ClearBackground();
28854
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 Py_INCREF(Py_None); resultobj = Py_None;
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28866 PyObject *resultobj;
28867 wxWindow *arg1 = (wxWindow *) 0 ;
28868 PyObject * obj0 = 0 ;
28869 char *kwnames[] = {
28870 (char *) "self", NULL
28871 };
28872
28873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28875 if (SWIG_arg_fail(1)) SWIG_fail;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 (arg1)->Freeze();
28879
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 Py_INCREF(Py_None); resultobj = Py_None;
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj;
28892 wxWindow *arg1 = (wxWindow *) 0 ;
28893 PyObject * obj0 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 (arg1)->Thaw();
28904
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 Py_INCREF(Py_None); resultobj = Py_None;
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28916 PyObject *resultobj;
28917 wxWindow *arg1 = (wxWindow *) 0 ;
28918 wxDC *arg2 = 0 ;
28919 PyObject * obj0 = 0 ;
28920 PyObject * obj1 = 0 ;
28921 char *kwnames[] = {
28922 (char *) "self",(char *) "dc", NULL
28923 };
28924
28925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28927 if (SWIG_arg_fail(1)) SWIG_fail;
28928 {
28929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28930 if (SWIG_arg_fail(2)) SWIG_fail;
28931 if (arg2 == NULL) {
28932 SWIG_null_ref("wxDC");
28933 }
28934 if (SWIG_arg_fail(2)) SWIG_fail;
28935 }
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 (arg1)->PrepareDC(*arg2);
28939
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 Py_INCREF(Py_None); resultobj = Py_None;
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj;
28952 wxWindow *arg1 = (wxWindow *) 0 ;
28953 wxRegion *result;
28954 PyObject * obj0 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 {
28965 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28966 result = (wxRegion *) &_result_ref;
28967 }
28968
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj;
28981 wxWindow *arg1 = (wxWindow *) 0 ;
28982 wxRect result;
28983 PyObject * obj0 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 {
28999 wxRect * resultptr;
29000 resultptr = new wxRect((wxRect &)(result));
29001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29002 }
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29010 PyObject *resultobj;
29011 wxWindow *arg1 = (wxWindow *) 0 ;
29012 int arg2 ;
29013 int arg3 ;
29014 int arg4 = (int) 1 ;
29015 int arg5 = (int) 1 ;
29016 bool result;
29017 PyObject * obj0 = 0 ;
29018 PyObject * obj1 = 0 ;
29019 PyObject * obj2 = 0 ;
29020 PyObject * obj3 = 0 ;
29021 PyObject * obj4 = 0 ;
29022 char *kwnames[] = {
29023 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29024 };
29025
29026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29028 if (SWIG_arg_fail(1)) SWIG_fail;
29029 {
29030 arg2 = (int)(SWIG_As_int(obj1));
29031 if (SWIG_arg_fail(2)) SWIG_fail;
29032 }
29033 {
29034 arg3 = (int)(SWIG_As_int(obj2));
29035 if (SWIG_arg_fail(3)) SWIG_fail;
29036 }
29037 if (obj3) {
29038 {
29039 arg4 = (int)(SWIG_As_int(obj3));
29040 if (SWIG_arg_fail(4)) SWIG_fail;
29041 }
29042 }
29043 if (obj4) {
29044 {
29045 arg5 = (int)(SWIG_As_int(obj4));
29046 if (SWIG_arg_fail(5)) SWIG_fail;
29047 }
29048 }
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29058 }
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj;
29067 wxWindow *arg1 = (wxWindow *) 0 ;
29068 wxPoint *arg2 = 0 ;
29069 bool result;
29070 wxPoint temp2 ;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 char *kwnames[] = {
29074 (char *) "self",(char *) "pt", NULL
29075 };
29076
29077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29079 if (SWIG_arg_fail(1)) SWIG_fail;
29080 {
29081 arg2 = &temp2;
29082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29083 }
29084 {
29085 PyThreadState* __tstate = wxPyBeginAllowThreads();
29086 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29087
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 {
29092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29093 }
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29101 PyObject *resultobj;
29102 wxWindow *arg1 = (wxWindow *) 0 ;
29103 wxRect *arg2 = 0 ;
29104 bool result;
29105 wxRect temp2 ;
29106 PyObject * obj0 = 0 ;
29107 PyObject * obj1 = 0 ;
29108 char *kwnames[] = {
29109 (char *) "self",(char *) "rect", NULL
29110 };
29111
29112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29114 if (SWIG_arg_fail(1)) SWIG_fail;
29115 {
29116 arg2 = &temp2;
29117 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29118 }
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29122
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 {
29127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29128 }
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29136 PyObject *resultobj;
29137 wxWindow *arg1 = (wxWindow *) 0 ;
29138 wxVisualAttributes result;
29139 PyObject * obj0 = 0 ;
29140 char *kwnames[] = {
29141 (char *) "self", NULL
29142 };
29143
29144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29146 if (SWIG_arg_fail(1)) SWIG_fail;
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29150
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 {
29155 wxVisualAttributes * resultptr;
29156 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29158 }
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29166 PyObject *resultobj;
29167 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29168 wxVisualAttributes result;
29169 PyObject * obj0 = 0 ;
29170 char *kwnames[] = {
29171 (char *) "variant", NULL
29172 };
29173
29174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29175 if (obj0) {
29176 {
29177 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 }
29180 }
29181 {
29182 if (!wxPyCheckForApp()) SWIG_fail;
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29185
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 {
29190 wxVisualAttributes * resultptr;
29191 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29193 }
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29201 PyObject *resultobj;
29202 wxWindow *arg1 = (wxWindow *) 0 ;
29203 wxColour *arg2 = 0 ;
29204 bool result;
29205 wxColour temp2 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "self",(char *) "colour", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29214 if (SWIG_arg_fail(1)) SWIG_fail;
29215 {
29216 arg2 = &temp2;
29217 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29218 }
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29222
29223 wxPyEndAllowThreads(__tstate);
29224 if (PyErr_Occurred()) SWIG_fail;
29225 }
29226 {
29227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29228 }
29229 return resultobj;
29230 fail:
29231 return NULL;
29232 }
29233
29234
29235 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29236 PyObject *resultobj;
29237 wxWindow *arg1 = (wxWindow *) 0 ;
29238 wxColour *arg2 = 0 ;
29239 wxColour temp2 ;
29240 PyObject * obj0 = 0 ;
29241 PyObject * obj1 = 0 ;
29242 char *kwnames[] = {
29243 (char *) "self",(char *) "colour", NULL
29244 };
29245
29246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29248 if (SWIG_arg_fail(1)) SWIG_fail;
29249 {
29250 arg2 = &temp2;
29251 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29252 }
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 Py_INCREF(Py_None); resultobj = Py_None;
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj;
29269 wxWindow *arg1 = (wxWindow *) 0 ;
29270 wxColour *arg2 = 0 ;
29271 bool result;
29272 wxColour temp2 ;
29273 PyObject * obj0 = 0 ;
29274 PyObject * obj1 = 0 ;
29275 char *kwnames[] = {
29276 (char *) "self",(char *) "colour", NULL
29277 };
29278
29279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29281 if (SWIG_arg_fail(1)) SWIG_fail;
29282 {
29283 arg2 = &temp2;
29284 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29285 }
29286 {
29287 PyThreadState* __tstate = wxPyBeginAllowThreads();
29288 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29289
29290 wxPyEndAllowThreads(__tstate);
29291 if (PyErr_Occurred()) SWIG_fail;
29292 }
29293 {
29294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29295 }
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxWindow *arg1 = (wxWindow *) 0 ;
29305 wxColour *arg2 = 0 ;
29306 wxColour temp2 ;
29307 PyObject * obj0 = 0 ;
29308 PyObject * obj1 = 0 ;
29309 char *kwnames[] = {
29310 (char *) "self",(char *) "colour", NULL
29311 };
29312
29313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29315 if (SWIG_arg_fail(1)) SWIG_fail;
29316 {
29317 arg2 = &temp2;
29318 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29319 }
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 (arg1)->SetOwnForegroundColour((wxColour 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_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29335 PyObject *resultobj;
29336 wxWindow *arg1 = (wxWindow *) 0 ;
29337 wxColour result;
29338 PyObject * obj0 = 0 ;
29339 char *kwnames[] = {
29340 (char *) "self", NULL
29341 };
29342
29343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",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 = ((wxWindow const *)arg1)->GetBackgroundColour();
29349
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 {
29354 wxColour * resultptr;
29355 resultptr = new wxColour((wxColour &)(result));
29356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29357 }
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj;
29366 wxWindow *arg1 = (wxWindow *) 0 ;
29367 wxColour result;
29368 PyObject * obj0 = 0 ;
29369 char *kwnames[] = {
29370 (char *) "self", NULL
29371 };
29372
29373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29375 if (SWIG_arg_fail(1)) SWIG_fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 result = ((wxWindow const *)arg1)->GetForegroundColour();
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 {
29384 wxColour * resultptr;
29385 resultptr = new wxColour((wxColour &)(result));
29386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29387 }
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj;
29396 wxWindow *arg1 = (wxWindow *) 0 ;
29397 wxBackgroundStyle arg2 ;
29398 bool result;
29399 PyObject * obj0 = 0 ;
29400 PyObject * obj1 = 0 ;
29401 char *kwnames[] = {
29402 (char *) "self",(char *) "style", NULL
29403 };
29404
29405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29407 if (SWIG_arg_fail(1)) SWIG_fail;
29408 {
29409 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29410 if (SWIG_arg_fail(2)) SWIG_fail;
29411 }
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29415
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 {
29420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29421 }
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29429 PyObject *resultobj;
29430 wxWindow *arg1 = (wxWindow *) 0 ;
29431 wxBackgroundStyle result;
29432 PyObject * obj0 = 0 ;
29433 char *kwnames[] = {
29434 (char *) "self", NULL
29435 };
29436
29437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29439 if (SWIG_arg_fail(1)) SWIG_fail;
29440 {
29441 PyThreadState* __tstate = wxPyBeginAllowThreads();
29442 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29443
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 resultobj = SWIG_From_int((result));
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29455 PyObject *resultobj;
29456 wxWindow *arg1 = (wxWindow *) 0 ;
29457 bool result;
29458 PyObject * obj0 = 0 ;
29459 char *kwnames[] = {
29460 (char *) "self", NULL
29461 };
29462
29463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29465 if (SWIG_arg_fail(1)) SWIG_fail;
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 result = (bool)(arg1)->HasTransparentBackground();
29469
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 {
29474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29475 }
29476 return resultobj;
29477 fail:
29478 return NULL;
29479 }
29480
29481
29482 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29483 PyObject *resultobj;
29484 wxWindow *arg1 = (wxWindow *) 0 ;
29485 wxCursor *arg2 = 0 ;
29486 bool result;
29487 PyObject * obj0 = 0 ;
29488 PyObject * obj1 = 0 ;
29489 char *kwnames[] = {
29490 (char *) "self",(char *) "cursor", NULL
29491 };
29492
29493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29495 if (SWIG_arg_fail(1)) SWIG_fail;
29496 {
29497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29498 if (SWIG_arg_fail(2)) SWIG_fail;
29499 if (arg2 == NULL) {
29500 SWIG_null_ref("wxCursor");
29501 }
29502 if (SWIG_arg_fail(2)) SWIG_fail;
29503 }
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29507
29508 wxPyEndAllowThreads(__tstate);
29509 if (PyErr_Occurred()) SWIG_fail;
29510 }
29511 {
29512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29513 }
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29521 PyObject *resultobj;
29522 wxWindow *arg1 = (wxWindow *) 0 ;
29523 wxCursor result;
29524 PyObject * obj0 = 0 ;
29525 char *kwnames[] = {
29526 (char *) "self", NULL
29527 };
29528
29529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29531 if (SWIG_arg_fail(1)) SWIG_fail;
29532 {
29533 PyThreadState* __tstate = wxPyBeginAllowThreads();
29534 result = (arg1)->GetCursor();
29535
29536 wxPyEndAllowThreads(__tstate);
29537 if (PyErr_Occurred()) SWIG_fail;
29538 }
29539 {
29540 wxCursor * resultptr;
29541 resultptr = new wxCursor((wxCursor &)(result));
29542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29543 }
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29551 PyObject *resultobj;
29552 wxWindow *arg1 = (wxWindow *) 0 ;
29553 wxFont *arg2 = 0 ;
29554 bool result;
29555 PyObject * obj0 = 0 ;
29556 PyObject * obj1 = 0 ;
29557 char *kwnames[] = {
29558 (char *) "self",(char *) "font", NULL
29559 };
29560
29561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29563 if (SWIG_arg_fail(1)) SWIG_fail;
29564 {
29565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29566 if (SWIG_arg_fail(2)) SWIG_fail;
29567 if (arg2 == NULL) {
29568 SWIG_null_ref("wxFont");
29569 }
29570 if (SWIG_arg_fail(2)) SWIG_fail;
29571 }
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29575
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29581 }
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj;
29590 wxWindow *arg1 = (wxWindow *) 0 ;
29591 wxFont *arg2 = 0 ;
29592 PyObject * obj0 = 0 ;
29593 PyObject * obj1 = 0 ;
29594 char *kwnames[] = {
29595 (char *) "self",(char *) "font", NULL
29596 };
29597
29598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29600 if (SWIG_arg_fail(1)) SWIG_fail;
29601 {
29602 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29603 if (SWIG_arg_fail(2)) SWIG_fail;
29604 if (arg2 == NULL) {
29605 SWIG_null_ref("wxFont");
29606 }
29607 if (SWIG_arg_fail(2)) SWIG_fail;
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 (arg1)->SetOwnFont((wxFont const &)*arg2);
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 Py_INCREF(Py_None); resultobj = Py_None;
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj;
29625 wxWindow *arg1 = (wxWindow *) 0 ;
29626 wxFont result;
29627 PyObject * obj0 = 0 ;
29628 char *kwnames[] = {
29629 (char *) "self", NULL
29630 };
29631
29632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29634 if (SWIG_arg_fail(1)) SWIG_fail;
29635 {
29636 PyThreadState* __tstate = wxPyBeginAllowThreads();
29637 result = (arg1)->GetFont();
29638
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 {
29643 wxFont * resultptr;
29644 resultptr = new wxFont((wxFont &)(result));
29645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29646 }
29647 return resultobj;
29648 fail:
29649 return NULL;
29650 }
29651
29652
29653 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29654 PyObject *resultobj;
29655 wxWindow *arg1 = (wxWindow *) 0 ;
29656 wxCaret *arg2 = (wxCaret *) 0 ;
29657 PyObject * obj0 = 0 ;
29658 PyObject * obj1 = 0 ;
29659 char *kwnames[] = {
29660 (char *) "self",(char *) "caret", NULL
29661 };
29662
29663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29665 if (SWIG_arg_fail(1)) SWIG_fail;
29666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29667 if (SWIG_arg_fail(2)) SWIG_fail;
29668 {
29669 PyThreadState* __tstate = wxPyBeginAllowThreads();
29670 (arg1)->SetCaret(arg2);
29671
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 Py_INCREF(Py_None); resultobj = Py_None;
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29683 PyObject *resultobj;
29684 wxWindow *arg1 = (wxWindow *) 0 ;
29685 wxCaret *result;
29686 PyObject * obj0 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29697
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29702 return resultobj;
29703 fail:
29704 return NULL;
29705 }
29706
29707
29708 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29709 PyObject *resultobj;
29710 wxWindow *arg1 = (wxWindow *) 0 ;
29711 int result;
29712 PyObject * obj0 = 0 ;
29713 char *kwnames[] = {
29714 (char *) "self", NULL
29715 };
29716
29717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29719 if (SWIG_arg_fail(1)) SWIG_fail;
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29723
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 {
29728 resultobj = SWIG_From_int((int)(result));
29729 }
29730 return resultobj;
29731 fail:
29732 return NULL;
29733 }
29734
29735
29736 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29737 PyObject *resultobj;
29738 wxWindow *arg1 = (wxWindow *) 0 ;
29739 int result;
29740 PyObject * obj0 = 0 ;
29741 char *kwnames[] = {
29742 (char *) "self", NULL
29743 };
29744
29745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29747 if (SWIG_arg_fail(1)) SWIG_fail;
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29751
29752 wxPyEndAllowThreads(__tstate);
29753 if (PyErr_Occurred()) SWIG_fail;
29754 }
29755 {
29756 resultobj = SWIG_From_int((int)(result));
29757 }
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj;
29766 wxWindow *arg1 = (wxWindow *) 0 ;
29767 wxString *arg2 = 0 ;
29768 int *arg3 = (int *) 0 ;
29769 int *arg4 = (int *) 0 ;
29770 bool temp2 = false ;
29771 int temp3 ;
29772 int res3 = 0 ;
29773 int temp4 ;
29774 int res4 = 0 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 char *kwnames[] = {
29778 (char *) "self",(char *) "string", NULL
29779 };
29780
29781 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29782 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
29788 if (arg2 == NULL) SWIG_fail;
29789 temp2 = true;
29790 }
29791 {
29792 PyThreadState* __tstate = wxPyBeginAllowThreads();
29793 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29794
29795 wxPyEndAllowThreads(__tstate);
29796 if (PyErr_Occurred()) SWIG_fail;
29797 }
29798 Py_INCREF(Py_None); resultobj = Py_None;
29799 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29800 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29801 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29802 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29803 {
29804 if (temp2)
29805 delete arg2;
29806 }
29807 return resultobj;
29808 fail:
29809 {
29810 if (temp2)
29811 delete arg2;
29812 }
29813 return NULL;
29814 }
29815
29816
29817 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29818 PyObject *resultobj;
29819 wxWindow *arg1 = (wxWindow *) 0 ;
29820 wxString *arg2 = 0 ;
29821 int *arg3 = (int *) 0 ;
29822 int *arg4 = (int *) 0 ;
29823 int *arg5 = (int *) 0 ;
29824 int *arg6 = (int *) 0 ;
29825 wxFont *arg7 = (wxFont *) NULL ;
29826 bool temp2 = false ;
29827 int temp3 ;
29828 int res3 = 0 ;
29829 int temp4 ;
29830 int res4 = 0 ;
29831 int temp5 ;
29832 int res5 = 0 ;
29833 int temp6 ;
29834 int res6 = 0 ;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 PyObject * obj2 = 0 ;
29838 char *kwnames[] = {
29839 (char *) "self",(char *) "string",(char *) "font", NULL
29840 };
29841
29842 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29843 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29844 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29845 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 arg2 = wxString_in_helper(obj1);
29851 if (arg2 == NULL) SWIG_fail;
29852 temp2 = true;
29853 }
29854 if (obj2) {
29855 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(7)) SWIG_fail;
29857 }
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29861
29862 wxPyEndAllowThreads(__tstate);
29863 if (PyErr_Occurred()) SWIG_fail;
29864 }
29865 Py_INCREF(Py_None); resultobj = Py_None;
29866 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29867 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29868 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29869 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29870 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29871 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29872 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29873 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29874 {
29875 if (temp2)
29876 delete arg2;
29877 }
29878 return resultobj;
29879 fail:
29880 {
29881 if (temp2)
29882 delete arg2;
29883 }
29884 return NULL;
29885 }
29886
29887
29888 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29889 PyObject *resultobj;
29890 wxWindow *arg1 = (wxWindow *) 0 ;
29891 int *arg2 = (int *) 0 ;
29892 int *arg3 = (int *) 0 ;
29893 int temp2 ;
29894 int res2 = 0 ;
29895 int temp3 ;
29896 int res3 = 0 ;
29897 PyObject * obj0 = 0 ;
29898 PyObject * obj1 = 0 ;
29899 PyObject * obj2 = 0 ;
29900 char *kwnames[] = {
29901 (char *) "self",(char *) "x",(char *) "y", NULL
29902 };
29903
29904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29906 if (SWIG_arg_fail(1)) SWIG_fail;
29907 {
29908 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29909 temp2 = SWIG_As_int(obj1);
29910 if (SWIG_arg_fail(2)) SWIG_fail;
29911 arg2 = &temp2;
29912 res2 = SWIG_NEWOBJ;
29913 }
29914 }
29915 {
29916 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29917 temp3 = SWIG_As_int(obj2);
29918 if (SWIG_arg_fail(3)) SWIG_fail;
29919 arg3 = &temp3;
29920 res3 = SWIG_NEWOBJ;
29921 }
29922 }
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29926
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 Py_INCREF(Py_None); resultobj = Py_None;
29931 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29932 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29933 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29934 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 int *arg2 = (int *) 0 ;
29945 int *arg3 = (int *) 0 ;
29946 int temp2 ;
29947 int res2 = 0 ;
29948 int temp3 ;
29949 int res3 = 0 ;
29950 PyObject * obj0 = 0 ;
29951 PyObject * obj1 = 0 ;
29952 PyObject * obj2 = 0 ;
29953 char *kwnames[] = {
29954 (char *) "self",(char *) "x",(char *) "y", NULL
29955 };
29956
29957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29959 if (SWIG_arg_fail(1)) SWIG_fail;
29960 {
29961 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29962 temp2 = SWIG_As_int(obj1);
29963 if (SWIG_arg_fail(2)) SWIG_fail;
29964 arg2 = &temp2;
29965 res2 = SWIG_NEWOBJ;
29966 }
29967 }
29968 {
29969 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29970 temp3 = SWIG_As_int(obj2);
29971 if (SWIG_arg_fail(3)) SWIG_fail;
29972 arg3 = &temp3;
29973 res3 = SWIG_NEWOBJ;
29974 }
29975 }
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29979
29980 wxPyEndAllowThreads(__tstate);
29981 if (PyErr_Occurred()) SWIG_fail;
29982 }
29983 Py_INCREF(Py_None); resultobj = Py_None;
29984 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29985 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29986 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29987 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29988 return resultobj;
29989 fail:
29990 return NULL;
29991 }
29992
29993
29994 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29995 PyObject *resultobj;
29996 wxWindow *arg1 = (wxWindow *) 0 ;
29997 wxPoint *arg2 = 0 ;
29998 wxPoint result;
29999 wxPoint temp2 ;
30000 PyObject * obj0 = 0 ;
30001 PyObject * obj1 = 0 ;
30002 char *kwnames[] = {
30003 (char *) "self",(char *) "pt", NULL
30004 };
30005
30006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30008 if (SWIG_arg_fail(1)) SWIG_fail;
30009 {
30010 arg2 = &temp2;
30011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30012 }
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30016
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 wxPoint * resultptr;
30022 resultptr = new wxPoint((wxPoint &)(result));
30023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30024 }
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj;
30033 wxWindow *arg1 = (wxWindow *) 0 ;
30034 wxPoint *arg2 = 0 ;
30035 wxPoint result;
30036 wxPoint temp2 ;
30037 PyObject * obj0 = 0 ;
30038 PyObject * obj1 = 0 ;
30039 char *kwnames[] = {
30040 (char *) "self",(char *) "pt", NULL
30041 };
30042
30043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30045 if (SWIG_arg_fail(1)) SWIG_fail;
30046 {
30047 arg2 = &temp2;
30048 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30049 }
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30053
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 {
30058 wxPoint * resultptr;
30059 resultptr = new wxPoint((wxPoint &)(result));
30060 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30061 }
30062 return resultobj;
30063 fail:
30064 return NULL;
30065 }
30066
30067
30068 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30069 PyObject *resultobj;
30070 wxWindow *arg1 = (wxWindow *) 0 ;
30071 int arg2 ;
30072 int arg3 ;
30073 wxHitTest result;
30074 PyObject * obj0 = 0 ;
30075 PyObject * obj1 = 0 ;
30076 PyObject * obj2 = 0 ;
30077 char *kwnames[] = {
30078 (char *) "self",(char *) "x",(char *) "y", NULL
30079 };
30080
30081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30083 if (SWIG_arg_fail(1)) SWIG_fail;
30084 {
30085 arg2 = (int)(SWIG_As_int(obj1));
30086 if (SWIG_arg_fail(2)) SWIG_fail;
30087 }
30088 {
30089 arg3 = (int)(SWIG_As_int(obj2));
30090 if (SWIG_arg_fail(3)) SWIG_fail;
30091 }
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30095
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 resultobj = SWIG_From_int((result));
30100 return resultobj;
30101 fail:
30102 return NULL;
30103 }
30104
30105
30106 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30107 PyObject *resultobj;
30108 wxWindow *arg1 = (wxWindow *) 0 ;
30109 wxPoint *arg2 = 0 ;
30110 wxHitTest result;
30111 wxPoint temp2 ;
30112 PyObject * obj0 = 0 ;
30113 PyObject * obj1 = 0 ;
30114 char *kwnames[] = {
30115 (char *) "self",(char *) "pt", NULL
30116 };
30117
30118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30120 if (SWIG_arg_fail(1)) SWIG_fail;
30121 {
30122 arg2 = &temp2;
30123 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30124 }
30125 {
30126 PyThreadState* __tstate = wxPyBeginAllowThreads();
30127 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30128
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 resultobj = SWIG_From_int((result));
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30140 PyObject *resultobj;
30141 wxWindow *arg1 = (wxWindow *) 0 ;
30142 long arg2 ;
30143 wxBorder result;
30144 PyObject * obj0 = 0 ;
30145 PyObject * obj1 = 0 ;
30146
30147 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30149 if (SWIG_arg_fail(1)) SWIG_fail;
30150 {
30151 arg2 = (long)(SWIG_As_long(obj1));
30152 if (SWIG_arg_fail(2)) SWIG_fail;
30153 }
30154 {
30155 PyThreadState* __tstate = wxPyBeginAllowThreads();
30156 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30157
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_From_int((result));
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30169 PyObject *resultobj;
30170 wxWindow *arg1 = (wxWindow *) 0 ;
30171 wxBorder result;
30172 PyObject * obj0 = 0 ;
30173
30174 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30176 if (SWIG_arg_fail(1)) SWIG_fail;
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30180
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 resultobj = SWIG_From_int((result));
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30192 int argc;
30193 PyObject *argv[3];
30194 int ii;
30195
30196 argc = PyObject_Length(args);
30197 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30198 argv[ii] = PyTuple_GetItem(args,ii);
30199 }
30200 if (argc == 1) {
30201 int _v;
30202 {
30203 void *ptr;
30204 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30205 _v = 0;
30206 PyErr_Clear();
30207 } else {
30208 _v = 1;
30209 }
30210 }
30211 if (_v) {
30212 return _wrap_Window_GetBorder__SWIG_1(self,args);
30213 }
30214 }
30215 if (argc == 2) {
30216 int _v;
30217 {
30218 void *ptr;
30219 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30220 _v = 0;
30221 PyErr_Clear();
30222 } else {
30223 _v = 1;
30224 }
30225 }
30226 if (_v) {
30227 _v = SWIG_Check_long(argv[1]);
30228 if (_v) {
30229 return _wrap_Window_GetBorder__SWIG_0(self,args);
30230 }
30231 }
30232 }
30233
30234 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30235 return NULL;
30236 }
30237
30238
30239 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30240 PyObject *resultobj;
30241 wxWindow *arg1 = (wxWindow *) 0 ;
30242 long arg2 = (long) wxUPDATE_UI_NONE ;
30243 PyObject * obj0 = 0 ;
30244 PyObject * obj1 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self",(char *) "flags", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 if (obj1) {
30253 {
30254 arg2 = (long)(SWIG_As_long(obj1));
30255 if (SWIG_arg_fail(2)) SWIG_fail;
30256 }
30257 }
30258 {
30259 PyThreadState* __tstate = wxPyBeginAllowThreads();
30260 (arg1)->UpdateWindowUI(arg2);
30261
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 Py_INCREF(Py_None); resultobj = Py_None;
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj;
30274 wxWindow *arg1 = (wxWindow *) 0 ;
30275 wxMenu *arg2 = (wxMenu *) 0 ;
30276 int arg3 = (int) -1 ;
30277 int arg4 = (int) -1 ;
30278 bool result;
30279 PyObject * obj0 = 0 ;
30280 PyObject * obj1 = 0 ;
30281 PyObject * obj2 = 0 ;
30282 PyObject * obj3 = 0 ;
30283 char *kwnames[] = {
30284 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30285 };
30286
30287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30289 if (SWIG_arg_fail(1)) SWIG_fail;
30290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(2)) SWIG_fail;
30292 if (obj2) {
30293 {
30294 arg3 = (int)(SWIG_As_int(obj2));
30295 if (SWIG_arg_fail(3)) SWIG_fail;
30296 }
30297 }
30298 if (obj3) {
30299 {
30300 arg4 = (int)(SWIG_As_int(obj3));
30301 if (SWIG_arg_fail(4)) SWIG_fail;
30302 }
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 {
30312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30313 }
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj;
30322 wxWindow *arg1 = (wxWindow *) 0 ;
30323 wxMenu *arg2 = (wxMenu *) 0 ;
30324 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30325 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30326 bool result;
30327 wxPoint temp3 ;
30328 PyObject * obj0 = 0 ;
30329 PyObject * obj1 = 0 ;
30330 PyObject * obj2 = 0 ;
30331 char *kwnames[] = {
30332 (char *) "self",(char *) "menu",(char *) "pos", NULL
30333 };
30334
30335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30337 if (SWIG_arg_fail(1)) SWIG_fail;
30338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30339 if (SWIG_arg_fail(2)) SWIG_fail;
30340 if (obj2) {
30341 {
30342 arg3 = &temp3;
30343 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30344 }
30345 }
30346 {
30347 PyThreadState* __tstate = wxPyBeginAllowThreads();
30348 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30349
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 {
30354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30355 }
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30363 PyObject *resultobj;
30364 wxWindow *arg1 = (wxWindow *) 0 ;
30365 long result;
30366 PyObject * obj0 = 0 ;
30367 char *kwnames[] = {
30368 (char *) "self", NULL
30369 };
30370
30371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30373 if (SWIG_arg_fail(1)) SWIG_fail;
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 result = (long)wxWindow_GetHandle(arg1);
30377
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 {
30382 resultobj = SWIG_From_long((long)(result));
30383 }
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj;
30392 wxWindow *arg1 = (wxWindow *) 0 ;
30393 long arg2 ;
30394 PyObject * obj0 = 0 ;
30395 PyObject * obj1 = 0 ;
30396 char *kwnames[] = {
30397 (char *) "self",(char *) "handle", NULL
30398 };
30399
30400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30402 if (SWIG_arg_fail(1)) SWIG_fail;
30403 {
30404 arg2 = (long)(SWIG_As_long(obj1));
30405 if (SWIG_arg_fail(2)) SWIG_fail;
30406 }
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 wxWindow_AssociateHandle(arg1,arg2);
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 Py_INCREF(Py_None); resultobj = Py_None;
30415 return resultobj;
30416 fail:
30417 return NULL;
30418 }
30419
30420
30421 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30422 PyObject *resultobj;
30423 wxWindow *arg1 = (wxWindow *) 0 ;
30424 PyObject * obj0 = 0 ;
30425 char *kwnames[] = {
30426 (char *) "self", NULL
30427 };
30428
30429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30431 if (SWIG_arg_fail(1)) SWIG_fail;
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 (arg1)->DissociateHandle();
30435
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 Py_INCREF(Py_None); resultobj = Py_None;
30440 return resultobj;
30441 fail:
30442 return NULL;
30443 }
30444
30445
30446 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30447 PyObject *resultobj;
30448 wxWindow *arg1 = (wxWindow *) 0 ;
30449 wxPaintEvent *arg2 = 0 ;
30450 PyObject * obj0 = 0 ;
30451 PyObject * obj1 = 0 ;
30452 char *kwnames[] = {
30453 (char *) "self",(char *) "event", NULL
30454 };
30455
30456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30458 if (SWIG_arg_fail(1)) SWIG_fail;
30459 {
30460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30461 if (SWIG_arg_fail(2)) SWIG_fail;
30462 if (arg2 == NULL) {
30463 SWIG_null_ref("wxPaintEvent");
30464 }
30465 if (SWIG_arg_fail(2)) SWIG_fail;
30466 }
30467 {
30468 PyThreadState* __tstate = wxPyBeginAllowThreads();
30469 (arg1)->OnPaint(*arg2);
30470
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 Py_INCREF(Py_None); resultobj = Py_None;
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30482 PyObject *resultobj;
30483 wxWindow *arg1 = (wxWindow *) 0 ;
30484 int arg2 ;
30485 bool result;
30486 PyObject * obj0 = 0 ;
30487 PyObject * obj1 = 0 ;
30488 char *kwnames[] = {
30489 (char *) "self",(char *) "orient", NULL
30490 };
30491
30492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30494 if (SWIG_arg_fail(1)) SWIG_fail;
30495 {
30496 arg2 = (int)(SWIG_As_int(obj1));
30497 if (SWIG_arg_fail(2)) SWIG_fail;
30498 }
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30502
30503 wxPyEndAllowThreads(__tstate);
30504 if (PyErr_Occurred()) SWIG_fail;
30505 }
30506 {
30507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30508 }
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxWindow *arg1 = (wxWindow *) 0 ;
30518 int arg2 ;
30519 int arg3 ;
30520 int arg4 ;
30521 int arg5 ;
30522 bool arg6 = (bool) true ;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 PyObject * obj2 = 0 ;
30526 PyObject * obj3 = 0 ;
30527 PyObject * obj4 = 0 ;
30528 PyObject * obj5 = 0 ;
30529 char *kwnames[] = {
30530 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30531 };
30532
30533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(1)) SWIG_fail;
30536 {
30537 arg2 = (int)(SWIG_As_int(obj1));
30538 if (SWIG_arg_fail(2)) SWIG_fail;
30539 }
30540 {
30541 arg3 = (int)(SWIG_As_int(obj2));
30542 if (SWIG_arg_fail(3)) SWIG_fail;
30543 }
30544 {
30545 arg4 = (int)(SWIG_As_int(obj3));
30546 if (SWIG_arg_fail(4)) SWIG_fail;
30547 }
30548 {
30549 arg5 = (int)(SWIG_As_int(obj4));
30550 if (SWIG_arg_fail(5)) SWIG_fail;
30551 }
30552 if (obj5) {
30553 {
30554 arg6 = (bool)(SWIG_As_bool(obj5));
30555 if (SWIG_arg_fail(6)) SWIG_fail;
30556 }
30557 }
30558 {
30559 PyThreadState* __tstate = wxPyBeginAllowThreads();
30560 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30561
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 Py_INCREF(Py_None); resultobj = Py_None;
30566 return resultobj;
30567 fail:
30568 return NULL;
30569 }
30570
30571
30572 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30573 PyObject *resultobj;
30574 wxWindow *arg1 = (wxWindow *) 0 ;
30575 int arg2 ;
30576 int arg3 ;
30577 bool arg4 = (bool) true ;
30578 PyObject * obj0 = 0 ;
30579 PyObject * obj1 = 0 ;
30580 PyObject * obj2 = 0 ;
30581 PyObject * obj3 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 arg2 = (int)(SWIG_As_int(obj1));
30591 if (SWIG_arg_fail(2)) SWIG_fail;
30592 }
30593 {
30594 arg3 = (int)(SWIG_As_int(obj2));
30595 if (SWIG_arg_fail(3)) SWIG_fail;
30596 }
30597 if (obj3) {
30598 {
30599 arg4 = (bool)(SWIG_As_bool(obj3));
30600 if (SWIG_arg_fail(4)) SWIG_fail;
30601 }
30602 }
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 (arg1)->SetScrollPos(arg2,arg3,arg4);
30606
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 Py_INCREF(Py_None); resultobj = Py_None;
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 int arg2 ;
30621 int result;
30622 PyObject * obj0 = 0 ;
30623 PyObject * obj1 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self",(char *) "orientation", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 arg2 = (int)(SWIG_As_int(obj1));
30633 if (SWIG_arg_fail(2)) SWIG_fail;
30634 }
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30638
30639 wxPyEndAllowThreads(__tstate);
30640 if (PyErr_Occurred()) SWIG_fail;
30641 }
30642 {
30643 resultobj = SWIG_From_int((int)(result));
30644 }
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30652 PyObject *resultobj;
30653 wxWindow *arg1 = (wxWindow *) 0 ;
30654 int arg2 ;
30655 int result;
30656 PyObject * obj0 = 0 ;
30657 PyObject * obj1 = 0 ;
30658 char *kwnames[] = {
30659 (char *) "self",(char *) "orientation", NULL
30660 };
30661
30662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30664 if (SWIG_arg_fail(1)) SWIG_fail;
30665 {
30666 arg2 = (int)(SWIG_As_int(obj1));
30667 if (SWIG_arg_fail(2)) SWIG_fail;
30668 }
30669 {
30670 PyThreadState* __tstate = wxPyBeginAllowThreads();
30671 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30672
30673 wxPyEndAllowThreads(__tstate);
30674 if (PyErr_Occurred()) SWIG_fail;
30675 }
30676 {
30677 resultobj = SWIG_From_int((int)(result));
30678 }
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 int arg2 ;
30689 int result;
30690 PyObject * obj0 = 0 ;
30691 PyObject * obj1 = 0 ;
30692 char *kwnames[] = {
30693 (char *) "self",(char *) "orientation", NULL
30694 };
30695
30696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30698 if (SWIG_arg_fail(1)) SWIG_fail;
30699 {
30700 arg2 = (int)(SWIG_As_int(obj1));
30701 if (SWIG_arg_fail(2)) SWIG_fail;
30702 }
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30706
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 {
30711 resultobj = SWIG_From_int((int)(result));
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 int arg2 ;
30723 int arg3 ;
30724 wxRect *arg4 = (wxRect *) NULL ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 PyObject * obj2 = 0 ;
30728 PyObject * obj3 = 0 ;
30729 char *kwnames[] = {
30730 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30731 };
30732
30733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30735 if (SWIG_arg_fail(1)) SWIG_fail;
30736 {
30737 arg2 = (int)(SWIG_As_int(obj1));
30738 if (SWIG_arg_fail(2)) SWIG_fail;
30739 }
30740 {
30741 arg3 = (int)(SWIG_As_int(obj2));
30742 if (SWIG_arg_fail(3)) SWIG_fail;
30743 }
30744 if (obj3) {
30745 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30746 if (SWIG_arg_fail(4)) SWIG_fail;
30747 }
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 Py_INCREF(Py_None); resultobj = Py_None;
30756 return resultobj;
30757 fail:
30758 return NULL;
30759 }
30760
30761
30762 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30763 PyObject *resultobj;
30764 wxWindow *arg1 = (wxWindow *) 0 ;
30765 int arg2 ;
30766 bool result;
30767 PyObject * obj0 = 0 ;
30768 PyObject * obj1 = 0 ;
30769 char *kwnames[] = {
30770 (char *) "self",(char *) "lines", NULL
30771 };
30772
30773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30775 if (SWIG_arg_fail(1)) SWIG_fail;
30776 {
30777 arg2 = (int)(SWIG_As_int(obj1));
30778 if (SWIG_arg_fail(2)) SWIG_fail;
30779 }
30780 {
30781 PyThreadState* __tstate = wxPyBeginAllowThreads();
30782 result = (bool)(arg1)->ScrollLines(arg2);
30783
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 {
30788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30789 }
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj;
30798 wxWindow *arg1 = (wxWindow *) 0 ;
30799 int arg2 ;
30800 bool result;
30801 PyObject * obj0 = 0 ;
30802 PyObject * obj1 = 0 ;
30803 char *kwnames[] = {
30804 (char *) "self",(char *) "pages", NULL
30805 };
30806
30807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30809 if (SWIG_arg_fail(1)) SWIG_fail;
30810 {
30811 arg2 = (int)(SWIG_As_int(obj1));
30812 if (SWIG_arg_fail(2)) SWIG_fail;
30813 }
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (bool)(arg1)->ScrollPages(arg2);
30817
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30823 }
30824 return resultobj;
30825 fail:
30826 return NULL;
30827 }
30828
30829
30830 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30831 PyObject *resultobj;
30832 wxWindow *arg1 = (wxWindow *) 0 ;
30833 bool result;
30834 PyObject * obj0 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "self", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",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 = (bool)(arg1)->LineUp();
30845
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 {
30850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30851 }
30852 return resultobj;
30853 fail:
30854 return NULL;
30855 }
30856
30857
30858 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30859 PyObject *resultobj;
30860 wxWindow *arg1 = (wxWindow *) 0 ;
30861 bool result;
30862 PyObject * obj0 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",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 = (bool)(arg1)->LineDown();
30873
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 {
30878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30879 }
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 wxWindow *arg1 = (wxWindow *) 0 ;
30889 bool result;
30890 PyObject * obj0 = 0 ;
30891 char *kwnames[] = {
30892 (char *) "self", NULL
30893 };
30894
30895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30897 if (SWIG_arg_fail(1)) SWIG_fail;
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = (bool)(arg1)->PageUp();
30901
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 {
30906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30907 }
30908 return resultobj;
30909 fail:
30910 return NULL;
30911 }
30912
30913
30914 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30915 PyObject *resultobj;
30916 wxWindow *arg1 = (wxWindow *) 0 ;
30917 bool result;
30918 PyObject * obj0 = 0 ;
30919 char *kwnames[] = {
30920 (char *) "self", NULL
30921 };
30922
30923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30925 if (SWIG_arg_fail(1)) SWIG_fail;
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 result = (bool)(arg1)->PageDown();
30929
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 {
30934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30935 }
30936 return resultobj;
30937 fail:
30938 return NULL;
30939 }
30940
30941
30942 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30943 PyObject *resultobj;
30944 wxWindow *arg1 = (wxWindow *) 0 ;
30945 wxString *arg2 = 0 ;
30946 bool temp2 = false ;
30947 PyObject * obj0 = 0 ;
30948 PyObject * obj1 = 0 ;
30949 char *kwnames[] = {
30950 (char *) "self",(char *) "text", NULL
30951 };
30952
30953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30955 if (SWIG_arg_fail(1)) SWIG_fail;
30956 {
30957 arg2 = wxString_in_helper(obj1);
30958 if (arg2 == NULL) SWIG_fail;
30959 temp2 = true;
30960 }
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 (arg1)->SetHelpText((wxString const &)*arg2);
30964
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 Py_INCREF(Py_None); resultobj = Py_None;
30969 {
30970 if (temp2)
30971 delete arg2;
30972 }
30973 return resultobj;
30974 fail:
30975 {
30976 if (temp2)
30977 delete arg2;
30978 }
30979 return NULL;
30980 }
30981
30982
30983 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30984 PyObject *resultobj;
30985 wxWindow *arg1 = (wxWindow *) 0 ;
30986 wxString *arg2 = 0 ;
30987 bool temp2 = false ;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 char *kwnames[] = {
30991 (char *) "self",(char *) "text", NULL
30992 };
30993
30994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30996 if (SWIG_arg_fail(1)) SWIG_fail;
30997 {
30998 arg2 = wxString_in_helper(obj1);
30999 if (arg2 == NULL) SWIG_fail;
31000 temp2 = true;
31001 }
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31005
31006 wxPyEndAllowThreads(__tstate);
31007 if (PyErr_Occurred()) SWIG_fail;
31008 }
31009 Py_INCREF(Py_None); resultobj = Py_None;
31010 {
31011 if (temp2)
31012 delete arg2;
31013 }
31014 return resultobj;
31015 fail:
31016 {
31017 if (temp2)
31018 delete arg2;
31019 }
31020 return NULL;
31021 }
31022
31023
31024 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxWindow *arg1 = (wxWindow *) 0 ;
31027 wxString result;
31028 PyObject * obj0 = 0 ;
31029 char *kwnames[] = {
31030 (char *) "self", NULL
31031 };
31032
31033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31035 if (SWIG_arg_fail(1)) SWIG_fail;
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 result = ((wxWindow const *)arg1)->GetHelpText();
31039
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 {
31044 #if wxUSE_UNICODE
31045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31046 #else
31047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31048 #endif
31049 }
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31057 PyObject *resultobj;
31058 wxWindow *arg1 = (wxWindow *) 0 ;
31059 wxString *arg2 = 0 ;
31060 bool temp2 = false ;
31061 PyObject * obj0 = 0 ;
31062 PyObject * obj1 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self",(char *) "tip", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 arg2 = wxString_in_helper(obj1);
31072 if (arg2 == NULL) SWIG_fail;
31073 temp2 = true;
31074 }
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 (arg1)->SetToolTip((wxString const &)*arg2);
31078
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 Py_INCREF(Py_None); resultobj = Py_None;
31083 {
31084 if (temp2)
31085 delete arg2;
31086 }
31087 return resultobj;
31088 fail:
31089 {
31090 if (temp2)
31091 delete arg2;
31092 }
31093 return NULL;
31094 }
31095
31096
31097 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 wxToolTip *arg2 = (wxToolTip *) 0 ;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char *kwnames[] = {
31104 (char *) "self",(char *) "tip", NULL
31105 };
31106
31107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31109 if (SWIG_arg_fail(1)) SWIG_fail;
31110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31111 if (SWIG_arg_fail(2)) SWIG_fail;
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 (arg1)->SetToolTip(arg2);
31115
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 Py_INCREF(Py_None); resultobj = Py_None;
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 wxToolTip *result;
31130 PyObject * obj0 = 0 ;
31131 char *kwnames[] = {
31132 (char *) "self", NULL
31133 };
31134
31135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31137 if (SWIG_arg_fail(1)) SWIG_fail;
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31141
31142 wxPyEndAllowThreads(__tstate);
31143 if (PyErr_Occurred()) SWIG_fail;
31144 }
31145 {
31146 resultobj = wxPyMake_wxObject(result, 0);
31147 }
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj;
31156 wxWindow *arg1 = (wxWindow *) 0 ;
31157 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self",(char *) "dropTarget", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31168 if (SWIG_arg_fail(2)) SWIG_fail;
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 (arg1)->SetDropTarget(arg2);
31172
31173 wxPyEndAllowThreads(__tstate);
31174 if (PyErr_Occurred()) SWIG_fail;
31175 }
31176 Py_INCREF(Py_None); resultobj = Py_None;
31177 return resultobj;
31178 fail:
31179 return NULL;
31180 }
31181
31182
31183 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31184 PyObject *resultobj;
31185 wxWindow *arg1 = (wxWindow *) 0 ;
31186 wxPyDropTarget *result;
31187 PyObject * obj0 = 0 ;
31188 char *kwnames[] = {
31189 (char *) "self", NULL
31190 };
31191
31192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31194 if (SWIG_arg_fail(1)) SWIG_fail;
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31198
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj;
31211 wxWindow *arg1 = (wxWindow *) 0 ;
31212 bool arg2 ;
31213 PyObject * obj0 = 0 ;
31214 PyObject * obj1 = 0 ;
31215 char *kwnames[] = {
31216 (char *) "self",(char *) "accept", NULL
31217 };
31218
31219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31221 if (SWIG_arg_fail(1)) SWIG_fail;
31222 {
31223 arg2 = (bool)(SWIG_As_bool(obj1));
31224 if (SWIG_arg_fail(2)) SWIG_fail;
31225 }
31226 {
31227 PyThreadState* __tstate = wxPyBeginAllowThreads();
31228 (arg1)->DragAcceptFiles(arg2);
31229
31230 wxPyEndAllowThreads(__tstate);
31231 if (PyErr_Occurred()) SWIG_fail;
31232 }
31233 Py_INCREF(Py_None); resultobj = Py_None;
31234 return resultobj;
31235 fail:
31236 return NULL;
31237 }
31238
31239
31240 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31241 PyObject *resultobj;
31242 wxWindow *arg1 = (wxWindow *) 0 ;
31243 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31244 PyObject * obj0 = 0 ;
31245 PyObject * obj1 = 0 ;
31246 char *kwnames[] = {
31247 (char *) "self",(char *) "constraints", NULL
31248 };
31249
31250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31252 if (SWIG_arg_fail(1)) SWIG_fail;
31253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31254 if (SWIG_arg_fail(2)) SWIG_fail;
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 (arg1)->SetConstraints(arg2);
31258
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 Py_INCREF(Py_None); resultobj = Py_None;
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj;
31271 wxWindow *arg1 = (wxWindow *) 0 ;
31272 wxLayoutConstraints *result;
31273 PyObject * obj0 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31284
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31289 return resultobj;
31290 fail:
31291 return NULL;
31292 }
31293
31294
31295 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31296 PyObject *resultobj;
31297 wxWindow *arg1 = (wxWindow *) 0 ;
31298 bool arg2 ;
31299 PyObject * obj0 = 0 ;
31300 PyObject * obj1 = 0 ;
31301 char *kwnames[] = {
31302 (char *) "self",(char *) "autoLayout", NULL
31303 };
31304
31305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31307 if (SWIG_arg_fail(1)) SWIG_fail;
31308 {
31309 arg2 = (bool)(SWIG_As_bool(obj1));
31310 if (SWIG_arg_fail(2)) SWIG_fail;
31311 }
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 (arg1)->SetAutoLayout(arg2);
31315
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 Py_INCREF(Py_None); resultobj = Py_None;
31320 return resultobj;
31321 fail:
31322 return NULL;
31323 }
31324
31325
31326 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31327 PyObject *resultobj;
31328 wxWindow *arg1 = (wxWindow *) 0 ;
31329 bool result;
31330 PyObject * obj0 = 0 ;
31331 char *kwnames[] = {
31332 (char *) "self", NULL
31333 };
31334
31335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31337 if (SWIG_arg_fail(1)) SWIG_fail;
31338 {
31339 PyThreadState* __tstate = wxPyBeginAllowThreads();
31340 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31341
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 {
31346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31347 }
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj;
31356 wxWindow *arg1 = (wxWindow *) 0 ;
31357 bool result;
31358 PyObject * obj0 = 0 ;
31359 char *kwnames[] = {
31360 (char *) "self", NULL
31361 };
31362
31363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31365 if (SWIG_arg_fail(1)) SWIG_fail;
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = (bool)(arg1)->Layout();
31369
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31375 }
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj;
31384 wxWindow *arg1 = (wxWindow *) 0 ;
31385 wxSizer *arg2 = (wxSizer *) 0 ;
31386 bool arg3 = (bool) true ;
31387 PyObject * obj0 = 0 ;
31388 PyObject * obj1 = 0 ;
31389 PyObject * obj2 = 0 ;
31390 char *kwnames[] = {
31391 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31392 };
31393
31394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31396 if (SWIG_arg_fail(1)) SWIG_fail;
31397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31398 if (SWIG_arg_fail(2)) SWIG_fail;
31399 if (obj2) {
31400 {
31401 arg3 = (bool)(SWIG_As_bool(obj2));
31402 if (SWIG_arg_fail(3)) SWIG_fail;
31403 }
31404 }
31405 {
31406 PyThreadState* __tstate = wxPyBeginAllowThreads();
31407 (arg1)->SetSizer(arg2,arg3);
31408
31409 wxPyEndAllowThreads(__tstate);
31410 if (PyErr_Occurred()) SWIG_fail;
31411 }
31412 Py_INCREF(Py_None); resultobj = Py_None;
31413 return resultobj;
31414 fail:
31415 return NULL;
31416 }
31417
31418
31419 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31420 PyObject *resultobj;
31421 wxWindow *arg1 = (wxWindow *) 0 ;
31422 wxSizer *arg2 = (wxSizer *) 0 ;
31423 bool arg3 = (bool) true ;
31424 PyObject * obj0 = 0 ;
31425 PyObject * obj1 = 0 ;
31426 PyObject * obj2 = 0 ;
31427 char *kwnames[] = {
31428 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31429 };
31430
31431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31433 if (SWIG_arg_fail(1)) SWIG_fail;
31434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31435 if (SWIG_arg_fail(2)) SWIG_fail;
31436 if (obj2) {
31437 {
31438 arg3 = (bool)(SWIG_As_bool(obj2));
31439 if (SWIG_arg_fail(3)) SWIG_fail;
31440 }
31441 }
31442 {
31443 PyThreadState* __tstate = wxPyBeginAllowThreads();
31444 (arg1)->SetSizerAndFit(arg2,arg3);
31445
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 Py_INCREF(Py_None); resultobj = Py_None;
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 wxSizer *result;
31460 PyObject * obj0 = 0 ;
31461 char *kwnames[] = {
31462 (char *) "self", NULL
31463 };
31464
31465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31467 if (SWIG_arg_fail(1)) SWIG_fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31471
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 {
31476 resultobj = wxPyMake_wxSizer(result, 0);
31477 }
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31485 PyObject *resultobj;
31486 wxWindow *arg1 = (wxWindow *) 0 ;
31487 wxSizer *arg2 = (wxSizer *) 0 ;
31488 PyObject * obj0 = 0 ;
31489 PyObject * obj1 = 0 ;
31490 char *kwnames[] = {
31491 (char *) "self",(char *) "sizer", NULL
31492 };
31493
31494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31496 if (SWIG_arg_fail(1)) SWIG_fail;
31497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31498 if (SWIG_arg_fail(2)) SWIG_fail;
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 (arg1)->SetContainingSizer(arg2);
31502
31503 wxPyEndAllowThreads(__tstate);
31504 if (PyErr_Occurred()) SWIG_fail;
31505 }
31506 Py_INCREF(Py_None); resultobj = Py_None;
31507 return resultobj;
31508 fail:
31509 return NULL;
31510 }
31511
31512
31513 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31514 PyObject *resultobj;
31515 wxWindow *arg1 = (wxWindow *) 0 ;
31516 wxSizer *result;
31517 PyObject * obj0 = 0 ;
31518 char *kwnames[] = {
31519 (char *) "self", NULL
31520 };
31521
31522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31528
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 {
31533 resultobj = wxPyMake_wxSizer(result, 0);
31534 }
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 PyObject * obj0 = 0 ;
31545 char *kwnames[] = {
31546 (char *) "self", NULL
31547 };
31548
31549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31551 if (SWIG_arg_fail(1)) SWIG_fail;
31552 {
31553 PyThreadState* __tstate = wxPyBeginAllowThreads();
31554 (arg1)->InheritAttributes();
31555
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 Py_INCREF(Py_None); resultobj = Py_None;
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31567 PyObject *resultobj;
31568 wxWindow *arg1 = (wxWindow *) 0 ;
31569 bool result;
31570 PyObject * obj0 = 0 ;
31571 char *kwnames[] = {
31572 (char *) "self", NULL
31573 };
31574
31575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31577 if (SWIG_arg_fail(1)) SWIG_fail;
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31581
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 {
31586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31587 }
31588 return resultobj;
31589 fail:
31590 return NULL;
31591 }
31592
31593
31594 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31595 PyObject *obj;
31596 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31597 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31598 Py_INCREF(obj);
31599 return Py_BuildValue((char *)"");
31600 }
31601 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31602 PyObject *resultobj;
31603 long arg1 ;
31604 wxWindow *arg2 = (wxWindow *) NULL ;
31605 wxWindow *result;
31606 PyObject * obj0 = 0 ;
31607 PyObject * obj1 = 0 ;
31608 char *kwnames[] = {
31609 (char *) "id",(char *) "parent", NULL
31610 };
31611
31612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31613 {
31614 arg1 = (long)(SWIG_As_long(obj0));
31615 if (SWIG_arg_fail(1)) SWIG_fail;
31616 }
31617 if (obj1) {
31618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31619 if (SWIG_arg_fail(2)) SWIG_fail;
31620 }
31621 {
31622 if (!wxPyCheckForApp()) SWIG_fail;
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31625
31626 wxPyEndAllowThreads(__tstate);
31627 if (PyErr_Occurred()) SWIG_fail;
31628 }
31629 {
31630 resultobj = wxPyMake_wxObject(result, 0);
31631 }
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj;
31640 wxString *arg1 = 0 ;
31641 wxWindow *arg2 = (wxWindow *) NULL ;
31642 wxWindow *result;
31643 bool temp1 = false ;
31644 PyObject * obj0 = 0 ;
31645 PyObject * obj1 = 0 ;
31646 char *kwnames[] = {
31647 (char *) "name",(char *) "parent", NULL
31648 };
31649
31650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31651 {
31652 arg1 = wxString_in_helper(obj0);
31653 if (arg1 == NULL) SWIG_fail;
31654 temp1 = true;
31655 }
31656 if (obj1) {
31657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31658 if (SWIG_arg_fail(2)) SWIG_fail;
31659 }
31660 {
31661 if (!wxPyCheckForApp()) SWIG_fail;
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31664
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 {
31669 resultobj = wxPyMake_wxObject(result, 0);
31670 }
31671 {
31672 if (temp1)
31673 delete arg1;
31674 }
31675 return resultobj;
31676 fail:
31677 {
31678 if (temp1)
31679 delete arg1;
31680 }
31681 return NULL;
31682 }
31683
31684
31685 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31686 PyObject *resultobj;
31687 wxString *arg1 = 0 ;
31688 wxWindow *arg2 = (wxWindow *) NULL ;
31689 wxWindow *result;
31690 bool temp1 = false ;
31691 PyObject * obj0 = 0 ;
31692 PyObject * obj1 = 0 ;
31693 char *kwnames[] = {
31694 (char *) "label",(char *) "parent", NULL
31695 };
31696
31697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31698 {
31699 arg1 = wxString_in_helper(obj0);
31700 if (arg1 == NULL) SWIG_fail;
31701 temp1 = true;
31702 }
31703 if (obj1) {
31704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31705 if (SWIG_arg_fail(2)) SWIG_fail;
31706 }
31707 {
31708 if (!wxPyCheckForApp()) SWIG_fail;
31709 PyThreadState* __tstate = wxPyBeginAllowThreads();
31710 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31711
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 {
31716 resultobj = wxPyMake_wxObject(result, 0);
31717 }
31718 {
31719 if (temp1)
31720 delete arg1;
31721 }
31722 return resultobj;
31723 fail:
31724 {
31725 if (temp1)
31726 delete arg1;
31727 }
31728 return NULL;
31729 }
31730
31731
31732 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31733 PyObject *resultobj;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 unsigned long arg2 ;
31736 wxWindow *result;
31737 PyObject * obj0 = 0 ;
31738 PyObject * obj1 = 0 ;
31739 char *kwnames[] = {
31740 (char *) "parent",(char *) "_hWnd", NULL
31741 };
31742
31743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31745 if (SWIG_arg_fail(1)) SWIG_fail;
31746 {
31747 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31748 if (SWIG_arg_fail(2)) SWIG_fail;
31749 }
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31753
31754 wxPyEndAllowThreads(__tstate);
31755 if (PyErr_Occurred()) SWIG_fail;
31756 }
31757 {
31758 resultobj = wxPyMake_wxObject(result, 0);
31759 }
31760 return resultobj;
31761 fail:
31762 return NULL;
31763 }
31764
31765
31766 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31767 PyObject *resultobj;
31768 wxValidator *result;
31769 char *kwnames[] = {
31770 NULL
31771 };
31772
31773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = (wxValidator *)new wxValidator();
31777
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj;
31790 wxValidator *arg1 = (wxValidator *) 0 ;
31791 wxValidator *result;
31792 PyObject * obj0 = 0 ;
31793 char *kwnames[] = {
31794 (char *) "self", NULL
31795 };
31796
31797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31799 if (SWIG_arg_fail(1)) SWIG_fail;
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 result = (wxValidator *)(arg1)->Clone();
31803
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 {
31808 resultobj = wxPyMake_wxObject(result, 0);
31809 }
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31817 PyObject *resultobj;
31818 wxValidator *arg1 = (wxValidator *) 0 ;
31819 wxWindow *arg2 = (wxWindow *) 0 ;
31820 bool result;
31821 PyObject * obj0 = 0 ;
31822 PyObject * obj1 = 0 ;
31823 char *kwnames[] = {
31824 (char *) "self",(char *) "parent", NULL
31825 };
31826
31827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31829 if (SWIG_arg_fail(1)) SWIG_fail;
31830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31831 if (SWIG_arg_fail(2)) SWIG_fail;
31832 {
31833 PyThreadState* __tstate = wxPyBeginAllowThreads();
31834 result = (bool)(arg1)->Validate(arg2);
31835
31836 wxPyEndAllowThreads(__tstate);
31837 if (PyErr_Occurred()) SWIG_fail;
31838 }
31839 {
31840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31841 }
31842 return resultobj;
31843 fail:
31844 return NULL;
31845 }
31846
31847
31848 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31849 PyObject *resultobj;
31850 wxValidator *arg1 = (wxValidator *) 0 ;
31851 bool result;
31852 PyObject * obj0 = 0 ;
31853 char *kwnames[] = {
31854 (char *) "self", NULL
31855 };
31856
31857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31859 if (SWIG_arg_fail(1)) SWIG_fail;
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 result = (bool)(arg1)->TransferToWindow();
31863
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 {
31868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31869 }
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31877 PyObject *resultobj;
31878 wxValidator *arg1 = (wxValidator *) 0 ;
31879 bool result;
31880 PyObject * obj0 = 0 ;
31881 char *kwnames[] = {
31882 (char *) "self", NULL
31883 };
31884
31885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31887 if (SWIG_arg_fail(1)) SWIG_fail;
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 result = (bool)(arg1)->TransferFromWindow();
31891
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 {
31896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31897 }
31898 return resultobj;
31899 fail:
31900 return NULL;
31901 }
31902
31903
31904 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31905 PyObject *resultobj;
31906 wxValidator *arg1 = (wxValidator *) 0 ;
31907 wxWindow *result;
31908 PyObject * obj0 = 0 ;
31909 char *kwnames[] = {
31910 (char *) "self", NULL
31911 };
31912
31913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31915 if (SWIG_arg_fail(1)) SWIG_fail;
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 result = (wxWindow *)(arg1)->GetWindow();
31919
31920 wxPyEndAllowThreads(__tstate);
31921 if (PyErr_Occurred()) SWIG_fail;
31922 }
31923 {
31924 resultobj = wxPyMake_wxObject(result, 0);
31925 }
31926 return resultobj;
31927 fail:
31928 return NULL;
31929 }
31930
31931
31932 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31933 PyObject *resultobj;
31934 wxValidator *arg1 = (wxValidator *) 0 ;
31935 wxWindow *arg2 = (wxWindow *) 0 ;
31936 PyObject * obj0 = 0 ;
31937 PyObject * obj1 = 0 ;
31938 char *kwnames[] = {
31939 (char *) "self",(char *) "window", NULL
31940 };
31941
31942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31944 if (SWIG_arg_fail(1)) SWIG_fail;
31945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31946 if (SWIG_arg_fail(2)) SWIG_fail;
31947 {
31948 PyThreadState* __tstate = wxPyBeginAllowThreads();
31949 (arg1)->SetWindow(arg2);
31950
31951 wxPyEndAllowThreads(__tstate);
31952 if (PyErr_Occurred()) SWIG_fail;
31953 }
31954 Py_INCREF(Py_None); resultobj = Py_None;
31955 return resultobj;
31956 fail:
31957 return NULL;
31958 }
31959
31960
31961 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31962 PyObject *resultobj;
31963 bool result;
31964 char *kwnames[] = {
31965 NULL
31966 };
31967
31968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = (bool)wxValidator::IsSilent();
31972
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 {
31977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31978 }
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31986 PyObject *resultobj;
31987 int arg1 = (int) true ;
31988 PyObject * obj0 = 0 ;
31989 char *kwnames[] = {
31990 (char *) "doIt", NULL
31991 };
31992
31993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31994 if (obj0) {
31995 {
31996 arg1 = (int)(SWIG_As_int(obj0));
31997 if (SWIG_arg_fail(1)) SWIG_fail;
31998 }
31999 }
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 wxValidator::SetBellOnError(arg1);
32003
32004 wxPyEndAllowThreads(__tstate);
32005 if (PyErr_Occurred()) SWIG_fail;
32006 }
32007 Py_INCREF(Py_None); resultobj = Py_None;
32008 return resultobj;
32009 fail:
32010 return NULL;
32011 }
32012
32013
32014 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32015 PyObject *obj;
32016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32017 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32018 Py_INCREF(obj);
32019 return Py_BuildValue((char *)"");
32020 }
32021 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32022 PyObject *resultobj;
32023 wxPyValidator *result;
32024 char *kwnames[] = {
32025 NULL
32026 };
32027
32028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32029 {
32030 PyThreadState* __tstate = wxPyBeginAllowThreads();
32031 result = (wxPyValidator *)new wxPyValidator();
32032
32033 wxPyEndAllowThreads(__tstate);
32034 if (PyErr_Occurred()) SWIG_fail;
32035 }
32036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32037 return resultobj;
32038 fail:
32039 return NULL;
32040 }
32041
32042
32043 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32044 PyObject *resultobj;
32045 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32046 PyObject *arg2 = (PyObject *) 0 ;
32047 PyObject *arg3 = (PyObject *) 0 ;
32048 int arg4 = (int) true ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 PyObject * obj2 = 0 ;
32052 PyObject * obj3 = 0 ;
32053 char *kwnames[] = {
32054 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32055 };
32056
32057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32059 if (SWIG_arg_fail(1)) SWIG_fail;
32060 arg2 = obj1;
32061 arg3 = obj2;
32062 if (obj3) {
32063 {
32064 arg4 = (int)(SWIG_As_int(obj3));
32065 if (SWIG_arg_fail(4)) SWIG_fail;
32066 }
32067 }
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32071
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 Py_INCREF(Py_None); resultobj = Py_None;
32076 return resultobj;
32077 fail:
32078 return NULL;
32079 }
32080
32081
32082 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32083 PyObject *obj;
32084 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32085 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32086 Py_INCREF(obj);
32087 return Py_BuildValue((char *)"");
32088 }
32089 static int _wrap_DefaultValidator_set(PyObject *) {
32090 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32091 return 1;
32092 }
32093
32094
32095 static PyObject *_wrap_DefaultValidator_get(void) {
32096 PyObject *pyobj;
32097
32098 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32099 return pyobj;
32100 }
32101
32102
32103 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj;
32105 wxString const &arg1_defvalue = wxPyEmptyString ;
32106 wxString *arg1 = (wxString *) &arg1_defvalue ;
32107 long arg2 = (long) 0 ;
32108 wxMenu *result;
32109 bool temp1 = false ;
32110 PyObject * obj0 = 0 ;
32111 PyObject * obj1 = 0 ;
32112 char *kwnames[] = {
32113 (char *) "title",(char *) "style", NULL
32114 };
32115
32116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32117 if (obj0) {
32118 {
32119 arg1 = wxString_in_helper(obj0);
32120 if (arg1 == NULL) SWIG_fail;
32121 temp1 = true;
32122 }
32123 }
32124 if (obj1) {
32125 {
32126 arg2 = (long)(SWIG_As_long(obj1));
32127 if (SWIG_arg_fail(2)) SWIG_fail;
32128 }
32129 }
32130 {
32131 if (!wxPyCheckForApp()) SWIG_fail;
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32134
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32139 {
32140 if (temp1)
32141 delete arg1;
32142 }
32143 return resultobj;
32144 fail:
32145 {
32146 if (temp1)
32147 delete arg1;
32148 }
32149 return NULL;
32150 }
32151
32152
32153 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32154 PyObject *resultobj;
32155 wxMenu *arg1 = (wxMenu *) 0 ;
32156 int arg2 ;
32157 wxString *arg3 = 0 ;
32158 wxString const &arg4_defvalue = wxPyEmptyString ;
32159 wxString *arg4 = (wxString *) &arg4_defvalue ;
32160 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32161 wxMenuItem *result;
32162 bool temp3 = false ;
32163 bool temp4 = false ;
32164 PyObject * obj0 = 0 ;
32165 PyObject * obj1 = 0 ;
32166 PyObject * obj2 = 0 ;
32167 PyObject * obj3 = 0 ;
32168 PyObject * obj4 = 0 ;
32169 char *kwnames[] = {
32170 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32171 };
32172
32173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32175 if (SWIG_arg_fail(1)) SWIG_fail;
32176 {
32177 arg2 = (int)(SWIG_As_int(obj1));
32178 if (SWIG_arg_fail(2)) SWIG_fail;
32179 }
32180 {
32181 arg3 = wxString_in_helper(obj2);
32182 if (arg3 == NULL) SWIG_fail;
32183 temp3 = true;
32184 }
32185 if (obj3) {
32186 {
32187 arg4 = wxString_in_helper(obj3);
32188 if (arg4 == NULL) SWIG_fail;
32189 temp4 = true;
32190 }
32191 }
32192 if (obj4) {
32193 {
32194 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32195 if (SWIG_arg_fail(5)) SWIG_fail;
32196 }
32197 }
32198 {
32199 PyThreadState* __tstate = wxPyBeginAllowThreads();
32200 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32201
32202 wxPyEndAllowThreads(__tstate);
32203 if (PyErr_Occurred()) SWIG_fail;
32204 }
32205 {
32206 resultobj = wxPyMake_wxObject(result, 0);
32207 }
32208 {
32209 if (temp3)
32210 delete arg3;
32211 }
32212 {
32213 if (temp4)
32214 delete arg4;
32215 }
32216 return resultobj;
32217 fail:
32218 {
32219 if (temp3)
32220 delete arg3;
32221 }
32222 {
32223 if (temp4)
32224 delete arg4;
32225 }
32226 return NULL;
32227 }
32228
32229
32230 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32231 PyObject *resultobj;
32232 wxMenu *arg1 = (wxMenu *) 0 ;
32233 wxMenuItem *result;
32234 PyObject * obj0 = 0 ;
32235 char *kwnames[] = {
32236 (char *) "self", NULL
32237 };
32238
32239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(1)) SWIG_fail;
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (wxMenuItem *)(arg1)->AppendSeparator();
32245
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 {
32250 resultobj = wxPyMake_wxObject(result, 0);
32251 }
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj;
32260 wxMenu *arg1 = (wxMenu *) 0 ;
32261 int arg2 ;
32262 wxString *arg3 = 0 ;
32263 wxString const &arg4_defvalue = wxPyEmptyString ;
32264 wxString *arg4 = (wxString *) &arg4_defvalue ;
32265 wxMenuItem *result;
32266 bool temp3 = false ;
32267 bool temp4 = false ;
32268 PyObject * obj0 = 0 ;
32269 PyObject * obj1 = 0 ;
32270 PyObject * obj2 = 0 ;
32271 PyObject * obj3 = 0 ;
32272 char *kwnames[] = {
32273 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32274 };
32275
32276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32278 if (SWIG_arg_fail(1)) SWIG_fail;
32279 {
32280 arg2 = (int)(SWIG_As_int(obj1));
32281 if (SWIG_arg_fail(2)) SWIG_fail;
32282 }
32283 {
32284 arg3 = wxString_in_helper(obj2);
32285 if (arg3 == NULL) SWIG_fail;
32286 temp3 = true;
32287 }
32288 if (obj3) {
32289 {
32290 arg4 = wxString_in_helper(obj3);
32291 if (arg4 == NULL) SWIG_fail;
32292 temp4 = true;
32293 }
32294 }
32295 {
32296 PyThreadState* __tstate = wxPyBeginAllowThreads();
32297 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32298
32299 wxPyEndAllowThreads(__tstate);
32300 if (PyErr_Occurred()) SWIG_fail;
32301 }
32302 {
32303 resultobj = wxPyMake_wxObject(result, 0);
32304 }
32305 {
32306 if (temp3)
32307 delete arg3;
32308 }
32309 {
32310 if (temp4)
32311 delete arg4;
32312 }
32313 return resultobj;
32314 fail:
32315 {
32316 if (temp3)
32317 delete arg3;
32318 }
32319 {
32320 if (temp4)
32321 delete arg4;
32322 }
32323 return NULL;
32324 }
32325
32326
32327 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj;
32329 wxMenu *arg1 = (wxMenu *) 0 ;
32330 int arg2 ;
32331 wxString *arg3 = 0 ;
32332 wxString const &arg4_defvalue = wxPyEmptyString ;
32333 wxString *arg4 = (wxString *) &arg4_defvalue ;
32334 wxMenuItem *result;
32335 bool temp3 = false ;
32336 bool temp4 = false ;
32337 PyObject * obj0 = 0 ;
32338 PyObject * obj1 = 0 ;
32339 PyObject * obj2 = 0 ;
32340 PyObject * obj3 = 0 ;
32341 char *kwnames[] = {
32342 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32343 };
32344
32345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32347 if (SWIG_arg_fail(1)) SWIG_fail;
32348 {
32349 arg2 = (int)(SWIG_As_int(obj1));
32350 if (SWIG_arg_fail(2)) SWIG_fail;
32351 }
32352 {
32353 arg3 = wxString_in_helper(obj2);
32354 if (arg3 == NULL) SWIG_fail;
32355 temp3 = true;
32356 }
32357 if (obj3) {
32358 {
32359 arg4 = wxString_in_helper(obj3);
32360 if (arg4 == NULL) SWIG_fail;
32361 temp4 = true;
32362 }
32363 }
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32367
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 {
32372 resultobj = wxPyMake_wxObject(result, 0);
32373 }
32374 {
32375 if (temp3)
32376 delete arg3;
32377 }
32378 {
32379 if (temp4)
32380 delete arg4;
32381 }
32382 return resultobj;
32383 fail:
32384 {
32385 if (temp3)
32386 delete arg3;
32387 }
32388 {
32389 if (temp4)
32390 delete arg4;
32391 }
32392 return NULL;
32393 }
32394
32395
32396 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32397 PyObject *resultobj;
32398 wxMenu *arg1 = (wxMenu *) 0 ;
32399 int arg2 ;
32400 wxString *arg3 = 0 ;
32401 wxMenu *arg4 = (wxMenu *) 0 ;
32402 wxString const &arg5_defvalue = wxPyEmptyString ;
32403 wxString *arg5 = (wxString *) &arg5_defvalue ;
32404 wxMenuItem *result;
32405 bool temp3 = false ;
32406 bool temp5 = false ;
32407 PyObject * obj0 = 0 ;
32408 PyObject * obj1 = 0 ;
32409 PyObject * obj2 = 0 ;
32410 PyObject * obj3 = 0 ;
32411 PyObject * obj4 = 0 ;
32412 char *kwnames[] = {
32413 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32414 };
32415
32416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32418 if (SWIG_arg_fail(1)) SWIG_fail;
32419 {
32420 arg2 = (int)(SWIG_As_int(obj1));
32421 if (SWIG_arg_fail(2)) SWIG_fail;
32422 }
32423 {
32424 arg3 = wxString_in_helper(obj2);
32425 if (arg3 == NULL) SWIG_fail;
32426 temp3 = true;
32427 }
32428 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32429 if (SWIG_arg_fail(4)) SWIG_fail;
32430 if (obj4) {
32431 {
32432 arg5 = wxString_in_helper(obj4);
32433 if (arg5 == NULL) SWIG_fail;
32434 temp5 = true;
32435 }
32436 }
32437 {
32438 PyThreadState* __tstate = wxPyBeginAllowThreads();
32439 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32440
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 {
32445 resultobj = wxPyMake_wxObject(result, 0);
32446 }
32447 {
32448 if (temp3)
32449 delete arg3;
32450 }
32451 {
32452 if (temp5)
32453 delete arg5;
32454 }
32455 return resultobj;
32456 fail:
32457 {
32458 if (temp3)
32459 delete arg3;
32460 }
32461 {
32462 if (temp5)
32463 delete arg5;
32464 }
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj;
32471 wxMenu *arg1 = (wxMenu *) 0 ;
32472 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32473 wxMenuItem *result;
32474 PyObject * obj0 = 0 ;
32475 PyObject * obj1 = 0 ;
32476 char *kwnames[] = {
32477 (char *) "self",(char *) "item", NULL
32478 };
32479
32480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32482 if (SWIG_arg_fail(1)) SWIG_fail;
32483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32484 if (SWIG_arg_fail(2)) SWIG_fail;
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (wxMenuItem *)(arg1)->Append(arg2);
32488
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 {
32493 resultobj = wxPyMake_wxObject(result, 0);
32494 }
32495 return resultobj;
32496 fail:
32497 return NULL;
32498 }
32499
32500
32501 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32502 PyObject *resultobj;
32503 wxMenu *arg1 = (wxMenu *) 0 ;
32504 PyObject * obj0 = 0 ;
32505 char *kwnames[] = {
32506 (char *) "self", NULL
32507 };
32508
32509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32511 if (SWIG_arg_fail(1)) SWIG_fail;
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 (arg1)->Break();
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 Py_INCREF(Py_None); resultobj = Py_None;
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj;
32528 wxMenu *arg1 = (wxMenu *) 0 ;
32529 size_t arg2 ;
32530 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32531 wxMenuItem *result;
32532 PyObject * obj0 = 0 ;
32533 PyObject * obj1 = 0 ;
32534 PyObject * obj2 = 0 ;
32535 char *kwnames[] = {
32536 (char *) "self",(char *) "pos",(char *) "item", NULL
32537 };
32538
32539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32541 if (SWIG_arg_fail(1)) SWIG_fail;
32542 {
32543 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32544 if (SWIG_arg_fail(2)) SWIG_fail;
32545 }
32546 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32547 if (SWIG_arg_fail(3)) SWIG_fail;
32548 {
32549 PyThreadState* __tstate = wxPyBeginAllowThreads();
32550 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32551
32552 wxPyEndAllowThreads(__tstate);
32553 if (PyErr_Occurred()) SWIG_fail;
32554 }
32555 {
32556 resultobj = wxPyMake_wxObject(result, 0);
32557 }
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj;
32566 wxMenu *arg1 = (wxMenu *) 0 ;
32567 size_t arg2 ;
32568 int arg3 ;
32569 wxString *arg4 = 0 ;
32570 wxString const &arg5_defvalue = wxPyEmptyString ;
32571 wxString *arg5 = (wxString *) &arg5_defvalue ;
32572 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32573 wxMenuItem *result;
32574 bool temp4 = false ;
32575 bool temp5 = false ;
32576 PyObject * obj0 = 0 ;
32577 PyObject * obj1 = 0 ;
32578 PyObject * obj2 = 0 ;
32579 PyObject * obj3 = 0 ;
32580 PyObject * obj4 = 0 ;
32581 PyObject * obj5 = 0 ;
32582 char *kwnames[] = {
32583 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32584 };
32585
32586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32588 if (SWIG_arg_fail(1)) SWIG_fail;
32589 {
32590 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32591 if (SWIG_arg_fail(2)) SWIG_fail;
32592 }
32593 {
32594 arg3 = (int)(SWIG_As_int(obj2));
32595 if (SWIG_arg_fail(3)) SWIG_fail;
32596 }
32597 {
32598 arg4 = wxString_in_helper(obj3);
32599 if (arg4 == NULL) SWIG_fail;
32600 temp4 = true;
32601 }
32602 if (obj4) {
32603 {
32604 arg5 = wxString_in_helper(obj4);
32605 if (arg5 == NULL) SWIG_fail;
32606 temp5 = true;
32607 }
32608 }
32609 if (obj5) {
32610 {
32611 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32612 if (SWIG_arg_fail(6)) SWIG_fail;
32613 }
32614 }
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32618
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 {
32623 resultobj = wxPyMake_wxObject(result, 0);
32624 }
32625 {
32626 if (temp4)
32627 delete arg4;
32628 }
32629 {
32630 if (temp5)
32631 delete arg5;
32632 }
32633 return resultobj;
32634 fail:
32635 {
32636 if (temp4)
32637 delete arg4;
32638 }
32639 {
32640 if (temp5)
32641 delete arg5;
32642 }
32643 return NULL;
32644 }
32645
32646
32647 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32648 PyObject *resultobj;
32649 wxMenu *arg1 = (wxMenu *) 0 ;
32650 size_t arg2 ;
32651 wxMenuItem *result;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 char *kwnames[] = {
32655 (char *) "self",(char *) "pos", NULL
32656 };
32657
32658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32660 if (SWIG_arg_fail(1)) SWIG_fail;
32661 {
32662 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32663 if (SWIG_arg_fail(2)) SWIG_fail;
32664 }
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32668
32669 wxPyEndAllowThreads(__tstate);
32670 if (PyErr_Occurred()) SWIG_fail;
32671 }
32672 {
32673 resultobj = wxPyMake_wxObject(result, 0);
32674 }
32675 return resultobj;
32676 fail:
32677 return NULL;
32678 }
32679
32680
32681 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32682 PyObject *resultobj;
32683 wxMenu *arg1 = (wxMenu *) 0 ;
32684 size_t arg2 ;
32685 int arg3 ;
32686 wxString *arg4 = 0 ;
32687 wxString const &arg5_defvalue = wxPyEmptyString ;
32688 wxString *arg5 = (wxString *) &arg5_defvalue ;
32689 wxMenuItem *result;
32690 bool temp4 = false ;
32691 bool temp5 = false ;
32692 PyObject * obj0 = 0 ;
32693 PyObject * obj1 = 0 ;
32694 PyObject * obj2 = 0 ;
32695 PyObject * obj3 = 0 ;
32696 PyObject * obj4 = 0 ;
32697 char *kwnames[] = {
32698 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32699 };
32700
32701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32703 if (SWIG_arg_fail(1)) SWIG_fail;
32704 {
32705 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32706 if (SWIG_arg_fail(2)) SWIG_fail;
32707 }
32708 {
32709 arg3 = (int)(SWIG_As_int(obj2));
32710 if (SWIG_arg_fail(3)) SWIG_fail;
32711 }
32712 {
32713 arg4 = wxString_in_helper(obj3);
32714 if (arg4 == NULL) SWIG_fail;
32715 temp4 = true;
32716 }
32717 if (obj4) {
32718 {
32719 arg5 = wxString_in_helper(obj4);
32720 if (arg5 == NULL) SWIG_fail;
32721 temp5 = true;
32722 }
32723 }
32724 {
32725 PyThreadState* __tstate = wxPyBeginAllowThreads();
32726 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32727
32728 wxPyEndAllowThreads(__tstate);
32729 if (PyErr_Occurred()) SWIG_fail;
32730 }
32731 {
32732 resultobj = wxPyMake_wxObject(result, 0);
32733 }
32734 {
32735 if (temp4)
32736 delete arg4;
32737 }
32738 {
32739 if (temp5)
32740 delete arg5;
32741 }
32742 return resultobj;
32743 fail:
32744 {
32745 if (temp4)
32746 delete arg4;
32747 }
32748 {
32749 if (temp5)
32750 delete arg5;
32751 }
32752 return NULL;
32753 }
32754
32755
32756 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32757 PyObject *resultobj;
32758 wxMenu *arg1 = (wxMenu *) 0 ;
32759 size_t arg2 ;
32760 int arg3 ;
32761 wxString *arg4 = 0 ;
32762 wxString const &arg5_defvalue = wxPyEmptyString ;
32763 wxString *arg5 = (wxString *) &arg5_defvalue ;
32764 wxMenuItem *result;
32765 bool temp4 = false ;
32766 bool temp5 = false ;
32767 PyObject * obj0 = 0 ;
32768 PyObject * obj1 = 0 ;
32769 PyObject * obj2 = 0 ;
32770 PyObject * obj3 = 0 ;
32771 PyObject * obj4 = 0 ;
32772 char *kwnames[] = {
32773 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32774 };
32775
32776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32778 if (SWIG_arg_fail(1)) SWIG_fail;
32779 {
32780 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32781 if (SWIG_arg_fail(2)) SWIG_fail;
32782 }
32783 {
32784 arg3 = (int)(SWIG_As_int(obj2));
32785 if (SWIG_arg_fail(3)) SWIG_fail;
32786 }
32787 {
32788 arg4 = wxString_in_helper(obj3);
32789 if (arg4 == NULL) SWIG_fail;
32790 temp4 = true;
32791 }
32792 if (obj4) {
32793 {
32794 arg5 = wxString_in_helper(obj4);
32795 if (arg5 == NULL) SWIG_fail;
32796 temp5 = true;
32797 }
32798 }
32799 {
32800 PyThreadState* __tstate = wxPyBeginAllowThreads();
32801 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32802
32803 wxPyEndAllowThreads(__tstate);
32804 if (PyErr_Occurred()) SWIG_fail;
32805 }
32806 {
32807 resultobj = wxPyMake_wxObject(result, 0);
32808 }
32809 {
32810 if (temp4)
32811 delete arg4;
32812 }
32813 {
32814 if (temp5)
32815 delete arg5;
32816 }
32817 return resultobj;
32818 fail:
32819 {
32820 if (temp4)
32821 delete arg4;
32822 }
32823 {
32824 if (temp5)
32825 delete arg5;
32826 }
32827 return NULL;
32828 }
32829
32830
32831 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32832 PyObject *resultobj;
32833 wxMenu *arg1 = (wxMenu *) 0 ;
32834 size_t arg2 ;
32835 int arg3 ;
32836 wxString *arg4 = 0 ;
32837 wxMenu *arg5 = (wxMenu *) 0 ;
32838 wxString const &arg6_defvalue = wxPyEmptyString ;
32839 wxString *arg6 = (wxString *) &arg6_defvalue ;
32840 wxMenuItem *result;
32841 bool temp4 = false ;
32842 bool temp6 = false ;
32843 PyObject * obj0 = 0 ;
32844 PyObject * obj1 = 0 ;
32845 PyObject * obj2 = 0 ;
32846 PyObject * obj3 = 0 ;
32847 PyObject * obj4 = 0 ;
32848 PyObject * obj5 = 0 ;
32849 char *kwnames[] = {
32850 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32851 };
32852
32853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32855 if (SWIG_arg_fail(1)) SWIG_fail;
32856 {
32857 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32858 if (SWIG_arg_fail(2)) SWIG_fail;
32859 }
32860 {
32861 arg3 = (int)(SWIG_As_int(obj2));
32862 if (SWIG_arg_fail(3)) SWIG_fail;
32863 }
32864 {
32865 arg4 = wxString_in_helper(obj3);
32866 if (arg4 == NULL) SWIG_fail;
32867 temp4 = true;
32868 }
32869 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32870 if (SWIG_arg_fail(5)) SWIG_fail;
32871 if (obj5) {
32872 {
32873 arg6 = wxString_in_helper(obj5);
32874 if (arg6 == NULL) SWIG_fail;
32875 temp6 = true;
32876 }
32877 }
32878 {
32879 PyThreadState* __tstate = wxPyBeginAllowThreads();
32880 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32881
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 {
32886 resultobj = wxPyMake_wxObject(result, 0);
32887 }
32888 {
32889 if (temp4)
32890 delete arg4;
32891 }
32892 {
32893 if (temp6)
32894 delete arg6;
32895 }
32896 return resultobj;
32897 fail:
32898 {
32899 if (temp4)
32900 delete arg4;
32901 }
32902 {
32903 if (temp6)
32904 delete arg6;
32905 }
32906 return NULL;
32907 }
32908
32909
32910 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj;
32912 wxMenu *arg1 = (wxMenu *) 0 ;
32913 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32914 wxMenuItem *result;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 char *kwnames[] = {
32918 (char *) "self",(char *) "item", NULL
32919 };
32920
32921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32923 if (SWIG_arg_fail(1)) SWIG_fail;
32924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32925 if (SWIG_arg_fail(2)) SWIG_fail;
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32929
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 {
32934 resultobj = wxPyMake_wxObject(result, 0);
32935 }
32936 return resultobj;
32937 fail:
32938 return NULL;
32939 }
32940
32941
32942 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32943 PyObject *resultobj;
32944 wxMenu *arg1 = (wxMenu *) 0 ;
32945 int arg2 ;
32946 wxString *arg3 = 0 ;
32947 wxString const &arg4_defvalue = wxPyEmptyString ;
32948 wxString *arg4 = (wxString *) &arg4_defvalue ;
32949 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32950 wxMenuItem *result;
32951 bool temp3 = false ;
32952 bool temp4 = false ;
32953 PyObject * obj0 = 0 ;
32954 PyObject * obj1 = 0 ;
32955 PyObject * obj2 = 0 ;
32956 PyObject * obj3 = 0 ;
32957 PyObject * obj4 = 0 ;
32958 char *kwnames[] = {
32959 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32960 };
32961
32962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32964 if (SWIG_arg_fail(1)) SWIG_fail;
32965 {
32966 arg2 = (int)(SWIG_As_int(obj1));
32967 if (SWIG_arg_fail(2)) SWIG_fail;
32968 }
32969 {
32970 arg3 = wxString_in_helper(obj2);
32971 if (arg3 == NULL) SWIG_fail;
32972 temp3 = true;
32973 }
32974 if (obj3) {
32975 {
32976 arg4 = wxString_in_helper(obj3);
32977 if (arg4 == NULL) SWIG_fail;
32978 temp4 = true;
32979 }
32980 }
32981 if (obj4) {
32982 {
32983 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32984 if (SWIG_arg_fail(5)) SWIG_fail;
32985 }
32986 }
32987 {
32988 PyThreadState* __tstate = wxPyBeginAllowThreads();
32989 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32990
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 {
32995 resultobj = wxPyMake_wxObject(result, 0);
32996 }
32997 {
32998 if (temp3)
32999 delete arg3;
33000 }
33001 {
33002 if (temp4)
33003 delete arg4;
33004 }
33005 return resultobj;
33006 fail:
33007 {
33008 if (temp3)
33009 delete arg3;
33010 }
33011 {
33012 if (temp4)
33013 delete arg4;
33014 }
33015 return NULL;
33016 }
33017
33018
33019 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33020 PyObject *resultobj;
33021 wxMenu *arg1 = (wxMenu *) 0 ;
33022 wxMenuItem *result;
33023 PyObject * obj0 = 0 ;
33024 char *kwnames[] = {
33025 (char *) "self", NULL
33026 };
33027
33028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33030 if (SWIG_arg_fail(1)) SWIG_fail;
33031 {
33032 PyThreadState* __tstate = wxPyBeginAllowThreads();
33033 result = (wxMenuItem *)(arg1)->PrependSeparator();
33034
33035 wxPyEndAllowThreads(__tstate);
33036 if (PyErr_Occurred()) SWIG_fail;
33037 }
33038 {
33039 resultobj = wxPyMake_wxObject(result, 0);
33040 }
33041 return resultobj;
33042 fail:
33043 return NULL;
33044 }
33045
33046
33047 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj;
33049 wxMenu *arg1 = (wxMenu *) 0 ;
33050 int arg2 ;
33051 wxString *arg3 = 0 ;
33052 wxString const &arg4_defvalue = wxPyEmptyString ;
33053 wxString *arg4 = (wxString *) &arg4_defvalue ;
33054 wxMenuItem *result;
33055 bool temp3 = false ;
33056 bool temp4 = false ;
33057 PyObject * obj0 = 0 ;
33058 PyObject * obj1 = 0 ;
33059 PyObject * obj2 = 0 ;
33060 PyObject * obj3 = 0 ;
33061 char *kwnames[] = {
33062 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33063 };
33064
33065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33067 if (SWIG_arg_fail(1)) SWIG_fail;
33068 {
33069 arg2 = (int)(SWIG_As_int(obj1));
33070 if (SWIG_arg_fail(2)) SWIG_fail;
33071 }
33072 {
33073 arg3 = wxString_in_helper(obj2);
33074 if (arg3 == NULL) SWIG_fail;
33075 temp3 = true;
33076 }
33077 if (obj3) {
33078 {
33079 arg4 = wxString_in_helper(obj3);
33080 if (arg4 == NULL) SWIG_fail;
33081 temp4 = true;
33082 }
33083 }
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33087
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 {
33092 resultobj = wxPyMake_wxObject(result, 0);
33093 }
33094 {
33095 if (temp3)
33096 delete arg3;
33097 }
33098 {
33099 if (temp4)
33100 delete arg4;
33101 }
33102 return resultobj;
33103 fail:
33104 {
33105 if (temp3)
33106 delete arg3;
33107 }
33108 {
33109 if (temp4)
33110 delete arg4;
33111 }
33112 return NULL;
33113 }
33114
33115
33116 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33117 PyObject *resultobj;
33118 wxMenu *arg1 = (wxMenu *) 0 ;
33119 int arg2 ;
33120 wxString *arg3 = 0 ;
33121 wxString const &arg4_defvalue = wxPyEmptyString ;
33122 wxString *arg4 = (wxString *) &arg4_defvalue ;
33123 wxMenuItem *result;
33124 bool temp3 = false ;
33125 bool temp4 = false ;
33126 PyObject * obj0 = 0 ;
33127 PyObject * obj1 = 0 ;
33128 PyObject * obj2 = 0 ;
33129 PyObject * obj3 = 0 ;
33130 char *kwnames[] = {
33131 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33132 };
33133
33134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33136 if (SWIG_arg_fail(1)) SWIG_fail;
33137 {
33138 arg2 = (int)(SWIG_As_int(obj1));
33139 if (SWIG_arg_fail(2)) SWIG_fail;
33140 }
33141 {
33142 arg3 = wxString_in_helper(obj2);
33143 if (arg3 == NULL) SWIG_fail;
33144 temp3 = true;
33145 }
33146 if (obj3) {
33147 {
33148 arg4 = wxString_in_helper(obj3);
33149 if (arg4 == NULL) SWIG_fail;
33150 temp4 = true;
33151 }
33152 }
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33156
33157 wxPyEndAllowThreads(__tstate);
33158 if (PyErr_Occurred()) SWIG_fail;
33159 }
33160 {
33161 resultobj = wxPyMake_wxObject(result, 0);
33162 }
33163 {
33164 if (temp3)
33165 delete arg3;
33166 }
33167 {
33168 if (temp4)
33169 delete arg4;
33170 }
33171 return resultobj;
33172 fail:
33173 {
33174 if (temp3)
33175 delete arg3;
33176 }
33177 {
33178 if (temp4)
33179 delete arg4;
33180 }
33181 return NULL;
33182 }
33183
33184
33185 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33186 PyObject *resultobj;
33187 wxMenu *arg1 = (wxMenu *) 0 ;
33188 int arg2 ;
33189 wxString *arg3 = 0 ;
33190 wxMenu *arg4 = (wxMenu *) 0 ;
33191 wxString const &arg5_defvalue = wxPyEmptyString ;
33192 wxString *arg5 = (wxString *) &arg5_defvalue ;
33193 wxMenuItem *result;
33194 bool temp3 = false ;
33195 bool temp5 = false ;
33196 PyObject * obj0 = 0 ;
33197 PyObject * obj1 = 0 ;
33198 PyObject * obj2 = 0 ;
33199 PyObject * obj3 = 0 ;
33200 PyObject * obj4 = 0 ;
33201 char *kwnames[] = {
33202 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33203 };
33204
33205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33207 if (SWIG_arg_fail(1)) SWIG_fail;
33208 {
33209 arg2 = (int)(SWIG_As_int(obj1));
33210 if (SWIG_arg_fail(2)) SWIG_fail;
33211 }
33212 {
33213 arg3 = wxString_in_helper(obj2);
33214 if (arg3 == NULL) SWIG_fail;
33215 temp3 = true;
33216 }
33217 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33218 if (SWIG_arg_fail(4)) SWIG_fail;
33219 if (obj4) {
33220 {
33221 arg5 = wxString_in_helper(obj4);
33222 if (arg5 == NULL) SWIG_fail;
33223 temp5 = true;
33224 }
33225 }
33226 {
33227 PyThreadState* __tstate = wxPyBeginAllowThreads();
33228 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33229
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 {
33234 resultobj = wxPyMake_wxObject(result, 0);
33235 }
33236 {
33237 if (temp3)
33238 delete arg3;
33239 }
33240 {
33241 if (temp5)
33242 delete arg5;
33243 }
33244 return resultobj;
33245 fail:
33246 {
33247 if (temp3)
33248 delete arg3;
33249 }
33250 {
33251 if (temp5)
33252 delete arg5;
33253 }
33254 return NULL;
33255 }
33256
33257
33258 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33259 PyObject *resultobj;
33260 wxMenu *arg1 = (wxMenu *) 0 ;
33261 int arg2 ;
33262 wxMenuItem *result;
33263 PyObject * obj0 = 0 ;
33264 PyObject * obj1 = 0 ;
33265 char *kwnames[] = {
33266 (char *) "self",(char *) "id", NULL
33267 };
33268
33269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33271 if (SWIG_arg_fail(1)) SWIG_fail;
33272 {
33273 arg2 = (int)(SWIG_As_int(obj1));
33274 if (SWIG_arg_fail(2)) SWIG_fail;
33275 }
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 result = (wxMenuItem *)(arg1)->Remove(arg2);
33279
33280 wxPyEndAllowThreads(__tstate);
33281 if (PyErr_Occurred()) SWIG_fail;
33282 }
33283 {
33284 resultobj = wxPyMake_wxObject(result, 0);
33285 }
33286 return resultobj;
33287 fail:
33288 return NULL;
33289 }
33290
33291
33292 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33293 PyObject *resultobj;
33294 wxMenu *arg1 = (wxMenu *) 0 ;
33295 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33296 wxMenuItem *result;
33297 PyObject * obj0 = 0 ;
33298 PyObject * obj1 = 0 ;
33299 char *kwnames[] = {
33300 (char *) "self",(char *) "item", NULL
33301 };
33302
33303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33305 if (SWIG_arg_fail(1)) SWIG_fail;
33306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33307 if (SWIG_arg_fail(2)) SWIG_fail;
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (wxMenuItem *)(arg1)->Remove(arg2);
33311
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 {
33316 resultobj = wxPyMake_wxObject(result, 0);
33317 }
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj;
33326 wxMenu *arg1 = (wxMenu *) 0 ;
33327 int arg2 ;
33328 bool result;
33329 PyObject * obj0 = 0 ;
33330 PyObject * obj1 = 0 ;
33331 char *kwnames[] = {
33332 (char *) "self",(char *) "id", NULL
33333 };
33334
33335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33337 if (SWIG_arg_fail(1)) SWIG_fail;
33338 {
33339 arg2 = (int)(SWIG_As_int(obj1));
33340 if (SWIG_arg_fail(2)) SWIG_fail;
33341 }
33342 {
33343 PyThreadState* __tstate = wxPyBeginAllowThreads();
33344 result = (bool)(arg1)->Delete(arg2);
33345
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33351 }
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33359 PyObject *resultobj;
33360 wxMenu *arg1 = (wxMenu *) 0 ;
33361 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33362 bool result;
33363 PyObject * obj0 = 0 ;
33364 PyObject * obj1 = 0 ;
33365 char *kwnames[] = {
33366 (char *) "self",(char *) "item", NULL
33367 };
33368
33369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33371 if (SWIG_arg_fail(1)) SWIG_fail;
33372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33373 if (SWIG_arg_fail(2)) SWIG_fail;
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 result = (bool)(arg1)->Delete(arg2);
33377
33378 wxPyEndAllowThreads(__tstate);
33379 if (PyErr_Occurred()) SWIG_fail;
33380 }
33381 {
33382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33383 }
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33391 PyObject *resultobj;
33392 wxMenu *arg1 = (wxMenu *) 0 ;
33393 PyObject * obj0 = 0 ;
33394 char *kwnames[] = {
33395 (char *) "self", NULL
33396 };
33397
33398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33400 if (SWIG_arg_fail(1)) SWIG_fail;
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 wxMenu_Destroy(arg1);
33404
33405 wxPyEndAllowThreads(__tstate);
33406 if (PyErr_Occurred()) SWIG_fail;
33407 }
33408 Py_INCREF(Py_None); resultobj = Py_None;
33409 return resultobj;
33410 fail:
33411 return NULL;
33412 }
33413
33414
33415 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33416 PyObject *resultobj;
33417 wxMenu *arg1 = (wxMenu *) 0 ;
33418 int arg2 ;
33419 bool result;
33420 PyObject * obj0 = 0 ;
33421 PyObject * obj1 = 0 ;
33422 char *kwnames[] = {
33423 (char *) "self",(char *) "id", NULL
33424 };
33425
33426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(1)) SWIG_fail;
33429 {
33430 arg2 = (int)(SWIG_As_int(obj1));
33431 if (SWIG_arg_fail(2)) SWIG_fail;
33432 }
33433 {
33434 PyThreadState* __tstate = wxPyBeginAllowThreads();
33435 result = (bool)(arg1)->Destroy(arg2);
33436
33437 wxPyEndAllowThreads(__tstate);
33438 if (PyErr_Occurred()) SWIG_fail;
33439 }
33440 {
33441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33442 }
33443 return resultobj;
33444 fail:
33445 return NULL;
33446 }
33447
33448
33449 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33450 PyObject *resultobj;
33451 wxMenu *arg1 = (wxMenu *) 0 ;
33452 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33453 bool result;
33454 PyObject * obj0 = 0 ;
33455 PyObject * obj1 = 0 ;
33456 char *kwnames[] = {
33457 (char *) "self",(char *) "item", NULL
33458 };
33459
33460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33462 if (SWIG_arg_fail(1)) SWIG_fail;
33463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33464 if (SWIG_arg_fail(2)) SWIG_fail;
33465 {
33466 PyThreadState* __tstate = wxPyBeginAllowThreads();
33467 result = (bool)(arg1)->Destroy(arg2);
33468
33469 wxPyEndAllowThreads(__tstate);
33470 if (PyErr_Occurred()) SWIG_fail;
33471 }
33472 {
33473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33474 }
33475 return resultobj;
33476 fail:
33477 return NULL;
33478 }
33479
33480
33481 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj;
33483 wxMenu *arg1 = (wxMenu *) 0 ;
33484 size_t result;
33485 PyObject * obj0 = 0 ;
33486 char *kwnames[] = {
33487 (char *) "self", NULL
33488 };
33489
33490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33492 if (SWIG_arg_fail(1)) SWIG_fail;
33493 {
33494 PyThreadState* __tstate = wxPyBeginAllowThreads();
33495 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33496
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 {
33501 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33502 }
33503 return resultobj;
33504 fail:
33505 return NULL;
33506 }
33507
33508
33509 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33510 PyObject *resultobj;
33511 wxMenu *arg1 = (wxMenu *) 0 ;
33512 PyObject *result;
33513 PyObject * obj0 = 0 ;
33514 char *kwnames[] = {
33515 (char *) "self", NULL
33516 };
33517
33518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33520 if (SWIG_arg_fail(1)) SWIG_fail;
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33524
33525 wxPyEndAllowThreads(__tstate);
33526 if (PyErr_Occurred()) SWIG_fail;
33527 }
33528 resultobj = result;
33529 return resultobj;
33530 fail:
33531 return NULL;
33532 }
33533
33534
33535 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33536 PyObject *resultobj;
33537 wxMenu *arg1 = (wxMenu *) 0 ;
33538 wxString *arg2 = 0 ;
33539 int result;
33540 bool temp2 = false ;
33541 PyObject * obj0 = 0 ;
33542 PyObject * obj1 = 0 ;
33543 char *kwnames[] = {
33544 (char *) "self",(char *) "item", NULL
33545 };
33546
33547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33549 if (SWIG_arg_fail(1)) SWIG_fail;
33550 {
33551 arg2 = wxString_in_helper(obj1);
33552 if (arg2 == NULL) SWIG_fail;
33553 temp2 = true;
33554 }
33555 {
33556 PyThreadState* __tstate = wxPyBeginAllowThreads();
33557 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33558
33559 wxPyEndAllowThreads(__tstate);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 }
33562 {
33563 resultobj = SWIG_From_int((int)(result));
33564 }
33565 {
33566 if (temp2)
33567 delete arg2;
33568 }
33569 return resultobj;
33570 fail:
33571 {
33572 if (temp2)
33573 delete arg2;
33574 }
33575 return NULL;
33576 }
33577
33578
33579 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33580 PyObject *resultobj;
33581 wxMenu *arg1 = (wxMenu *) 0 ;
33582 int arg2 ;
33583 wxMenuItem *result;
33584 PyObject * obj0 = 0 ;
33585 PyObject * obj1 = 0 ;
33586 char *kwnames[] = {
33587 (char *) "self",(char *) "id", NULL
33588 };
33589
33590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33592 if (SWIG_arg_fail(1)) SWIG_fail;
33593 {
33594 arg2 = (int)(SWIG_As_int(obj1));
33595 if (SWIG_arg_fail(2)) SWIG_fail;
33596 }
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33600
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = wxPyMake_wxObject(result, 0);
33606 }
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj;
33615 wxMenu *arg1 = (wxMenu *) 0 ;
33616 size_t arg2 ;
33617 wxMenuItem *result;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 char *kwnames[] = {
33621 (char *) "self",(char *) "position", NULL
33622 };
33623
33624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33626 if (SWIG_arg_fail(1)) SWIG_fail;
33627 {
33628 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33629 if (SWIG_arg_fail(2)) SWIG_fail;
33630 }
33631 {
33632 PyThreadState* __tstate = wxPyBeginAllowThreads();
33633 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33634
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = wxPyMake_wxObject(result, 0);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33648 PyObject *resultobj;
33649 wxMenu *arg1 = (wxMenu *) 0 ;
33650 int arg2 ;
33651 bool arg3 ;
33652 PyObject * obj0 = 0 ;
33653 PyObject * obj1 = 0 ;
33654 PyObject * obj2 = 0 ;
33655 char *kwnames[] = {
33656 (char *) "self",(char *) "id",(char *) "enable", NULL
33657 };
33658
33659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33661 if (SWIG_arg_fail(1)) SWIG_fail;
33662 {
33663 arg2 = (int)(SWIG_As_int(obj1));
33664 if (SWIG_arg_fail(2)) SWIG_fail;
33665 }
33666 {
33667 arg3 = (bool)(SWIG_As_bool(obj2));
33668 if (SWIG_arg_fail(3)) SWIG_fail;
33669 }
33670 {
33671 PyThreadState* __tstate = wxPyBeginAllowThreads();
33672 (arg1)->Enable(arg2,arg3);
33673
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 Py_INCREF(Py_None); resultobj = Py_None;
33678 return resultobj;
33679 fail:
33680 return NULL;
33681 }
33682
33683
33684 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj;
33686 wxMenu *arg1 = (wxMenu *) 0 ;
33687 int arg2 ;
33688 bool result;
33689 PyObject * obj0 = 0 ;
33690 PyObject * obj1 = 0 ;
33691 char *kwnames[] = {
33692 (char *) "self",(char *) "id", NULL
33693 };
33694
33695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) 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 = (int)(SWIG_As_int(obj1));
33700 if (SWIG_arg_fail(2)) SWIG_fail;
33701 }
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33705
33706 wxPyEndAllowThreads(__tstate);
33707 if (PyErr_Occurred()) SWIG_fail;
33708 }
33709 {
33710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33711 }
33712 return resultobj;
33713 fail:
33714 return NULL;
33715 }
33716
33717
33718 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj;
33720 wxMenu *arg1 = (wxMenu *) 0 ;
33721 int arg2 ;
33722 bool arg3 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 PyObject * obj2 = 0 ;
33726 char *kwnames[] = {
33727 (char *) "self",(char *) "id",(char *) "check", NULL
33728 };
33729
33730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33732 if (SWIG_arg_fail(1)) SWIG_fail;
33733 {
33734 arg2 = (int)(SWIG_As_int(obj1));
33735 if (SWIG_arg_fail(2)) SWIG_fail;
33736 }
33737 {
33738 arg3 = (bool)(SWIG_As_bool(obj2));
33739 if (SWIG_arg_fail(3)) SWIG_fail;
33740 }
33741 {
33742 PyThreadState* __tstate = wxPyBeginAllowThreads();
33743 (arg1)->Check(arg2,arg3);
33744
33745 wxPyEndAllowThreads(__tstate);
33746 if (PyErr_Occurred()) SWIG_fail;
33747 }
33748 Py_INCREF(Py_None); resultobj = Py_None;
33749 return resultobj;
33750 fail:
33751 return NULL;
33752 }
33753
33754
33755 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33756 PyObject *resultobj;
33757 wxMenu *arg1 = (wxMenu *) 0 ;
33758 int arg2 ;
33759 bool result;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char *kwnames[] = {
33763 (char *) "self",(char *) "id", NULL
33764 };
33765
33766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33768 if (SWIG_arg_fail(1)) SWIG_fail;
33769 {
33770 arg2 = (int)(SWIG_As_int(obj1));
33771 if (SWIG_arg_fail(2)) SWIG_fail;
33772 }
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33776
33777 wxPyEndAllowThreads(__tstate);
33778 if (PyErr_Occurred()) SWIG_fail;
33779 }
33780 {
33781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33782 }
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj;
33791 wxMenu *arg1 = (wxMenu *) 0 ;
33792 int arg2 ;
33793 wxString *arg3 = 0 ;
33794 bool temp3 = false ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 PyObject * obj2 = 0 ;
33798 char *kwnames[] = {
33799 (char *) "self",(char *) "id",(char *) "label", NULL
33800 };
33801
33802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33804 if (SWIG_arg_fail(1)) SWIG_fail;
33805 {
33806 arg2 = (int)(SWIG_As_int(obj1));
33807 if (SWIG_arg_fail(2)) SWIG_fail;
33808 }
33809 {
33810 arg3 = wxString_in_helper(obj2);
33811 if (arg3 == NULL) SWIG_fail;
33812 temp3 = true;
33813 }
33814 {
33815 PyThreadState* __tstate = wxPyBeginAllowThreads();
33816 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33817
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 Py_INCREF(Py_None); resultobj = Py_None;
33822 {
33823 if (temp3)
33824 delete arg3;
33825 }
33826 return resultobj;
33827 fail:
33828 {
33829 if (temp3)
33830 delete arg3;
33831 }
33832 return NULL;
33833 }
33834
33835
33836 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33837 PyObject *resultobj;
33838 wxMenu *arg1 = (wxMenu *) 0 ;
33839 int arg2 ;
33840 wxString result;
33841 PyObject * obj0 = 0 ;
33842 PyObject * obj1 = 0 ;
33843 char *kwnames[] = {
33844 (char *) "self",(char *) "id", NULL
33845 };
33846
33847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33849 if (SWIG_arg_fail(1)) SWIG_fail;
33850 {
33851 arg2 = (int)(SWIG_As_int(obj1));
33852 if (SWIG_arg_fail(2)) SWIG_fail;
33853 }
33854 {
33855 PyThreadState* __tstate = wxPyBeginAllowThreads();
33856 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33857
33858 wxPyEndAllowThreads(__tstate);
33859 if (PyErr_Occurred()) SWIG_fail;
33860 }
33861 {
33862 #if wxUSE_UNICODE
33863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33864 #else
33865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33866 #endif
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj;
33876 wxMenu *arg1 = (wxMenu *) 0 ;
33877 int arg2 ;
33878 wxString *arg3 = 0 ;
33879 bool temp3 = false ;
33880 PyObject * obj0 = 0 ;
33881 PyObject * obj1 = 0 ;
33882 PyObject * obj2 = 0 ;
33883 char *kwnames[] = {
33884 (char *) "self",(char *) "id",(char *) "helpString", NULL
33885 };
33886
33887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33889 if (SWIG_arg_fail(1)) SWIG_fail;
33890 {
33891 arg2 = (int)(SWIG_As_int(obj1));
33892 if (SWIG_arg_fail(2)) SWIG_fail;
33893 }
33894 {
33895 arg3 = wxString_in_helper(obj2);
33896 if (arg3 == NULL) SWIG_fail;
33897 temp3 = true;
33898 }
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33902
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 Py_INCREF(Py_None); resultobj = Py_None;
33907 {
33908 if (temp3)
33909 delete arg3;
33910 }
33911 return resultobj;
33912 fail:
33913 {
33914 if (temp3)
33915 delete arg3;
33916 }
33917 return NULL;
33918 }
33919
33920
33921 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj;
33923 wxMenu *arg1 = (wxMenu *) 0 ;
33924 int arg2 ;
33925 wxString result;
33926 PyObject * obj0 = 0 ;
33927 PyObject * obj1 = 0 ;
33928 char *kwnames[] = {
33929 (char *) "self",(char *) "id", NULL
33930 };
33931
33932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33934 if (SWIG_arg_fail(1)) SWIG_fail;
33935 {
33936 arg2 = (int)(SWIG_As_int(obj1));
33937 if (SWIG_arg_fail(2)) SWIG_fail;
33938 }
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33942
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 {
33947 #if wxUSE_UNICODE
33948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33949 #else
33950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33951 #endif
33952 }
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj;
33961 wxMenu *arg1 = (wxMenu *) 0 ;
33962 wxString *arg2 = 0 ;
33963 bool temp2 = false ;
33964 PyObject * obj0 = 0 ;
33965 PyObject * obj1 = 0 ;
33966 char *kwnames[] = {
33967 (char *) "self",(char *) "title", NULL
33968 };
33969
33970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33972 if (SWIG_arg_fail(1)) SWIG_fail;
33973 {
33974 arg2 = wxString_in_helper(obj1);
33975 if (arg2 == NULL) SWIG_fail;
33976 temp2 = true;
33977 }
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 (arg1)->SetTitle((wxString const &)*arg2);
33981
33982 wxPyEndAllowThreads(__tstate);
33983 if (PyErr_Occurred()) SWIG_fail;
33984 }
33985 Py_INCREF(Py_None); resultobj = Py_None;
33986 {
33987 if (temp2)
33988 delete arg2;
33989 }
33990 return resultobj;
33991 fail:
33992 {
33993 if (temp2)
33994 delete arg2;
33995 }
33996 return NULL;
33997 }
33998
33999
34000 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34001 PyObject *resultobj;
34002 wxMenu *arg1 = (wxMenu *) 0 ;
34003 wxString result;
34004 PyObject * obj0 = 0 ;
34005 char *kwnames[] = {
34006 (char *) "self", NULL
34007 };
34008
34009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34011 if (SWIG_arg_fail(1)) SWIG_fail;
34012 {
34013 PyThreadState* __tstate = wxPyBeginAllowThreads();
34014 result = ((wxMenu const *)arg1)->GetTitle();
34015
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 {
34020 #if wxUSE_UNICODE
34021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34022 #else
34023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34024 #endif
34025 }
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj;
34034 wxMenu *arg1 = (wxMenu *) 0 ;
34035 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34036 PyObject * obj0 = 0 ;
34037 PyObject * obj1 = 0 ;
34038 char *kwnames[] = {
34039 (char *) "self",(char *) "handler", NULL
34040 };
34041
34042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34044 if (SWIG_arg_fail(1)) SWIG_fail;
34045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34046 if (SWIG_arg_fail(2)) SWIG_fail;
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 (arg1)->SetEventHandler(arg2);
34050
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 Py_INCREF(Py_None); resultobj = Py_None;
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34062 PyObject *resultobj;
34063 wxMenu *arg1 = (wxMenu *) 0 ;
34064 wxEvtHandler *result;
34065 PyObject * obj0 = 0 ;
34066 char *kwnames[] = {
34067 (char *) "self", NULL
34068 };
34069
34070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34072 if (SWIG_arg_fail(1)) SWIG_fail;
34073 {
34074 PyThreadState* __tstate = wxPyBeginAllowThreads();
34075 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34076
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 {
34081 resultobj = wxPyMake_wxObject(result, 0);
34082 }
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 wxWindow *arg2 = (wxWindow *) 0 ;
34093 PyObject * obj0 = 0 ;
34094 PyObject * obj1 = 0 ;
34095 char *kwnames[] = {
34096 (char *) "self",(char *) "win", NULL
34097 };
34098
34099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34101 if (SWIG_arg_fail(1)) SWIG_fail;
34102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34103 if (SWIG_arg_fail(2)) SWIG_fail;
34104 {
34105 PyThreadState* __tstate = wxPyBeginAllowThreads();
34106 (arg1)->SetInvokingWindow(arg2);
34107
34108 wxPyEndAllowThreads(__tstate);
34109 if (PyErr_Occurred()) SWIG_fail;
34110 }
34111 Py_INCREF(Py_None); resultobj = Py_None;
34112 return resultobj;
34113 fail:
34114 return NULL;
34115 }
34116
34117
34118 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj;
34120 wxMenu *arg1 = (wxMenu *) 0 ;
34121 wxWindow *result;
34122 PyObject * obj0 = 0 ;
34123 char *kwnames[] = {
34124 (char *) "self", NULL
34125 };
34126
34127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34129 if (SWIG_arg_fail(1)) SWIG_fail;
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34133
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 {
34138 resultobj = wxPyMake_wxObject(result, 0);
34139 }
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj;
34148 wxMenu *arg1 = (wxMenu *) 0 ;
34149 long result;
34150 PyObject * obj0 = 0 ;
34151 char *kwnames[] = {
34152 (char *) "self", NULL
34153 };
34154
34155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34157 if (SWIG_arg_fail(1)) SWIG_fail;
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 result = (long)((wxMenu const *)arg1)->GetStyle();
34161
34162 wxPyEndAllowThreads(__tstate);
34163 if (PyErr_Occurred()) SWIG_fail;
34164 }
34165 {
34166 resultobj = SWIG_From_long((long)(result));
34167 }
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj;
34176 wxMenu *arg1 = (wxMenu *) 0 ;
34177 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34178 PyObject * obj0 = 0 ;
34179 PyObject * obj1 = 0 ;
34180 char *kwnames[] = {
34181 (char *) "self",(char *) "source", NULL
34182 };
34183
34184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34186 if (SWIG_arg_fail(1)) SWIG_fail;
34187 if (obj1) {
34188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34189 if (SWIG_arg_fail(2)) SWIG_fail;
34190 }
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 (arg1)->UpdateUI(arg2);
34194
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 Py_INCREF(Py_None); resultobj = Py_None;
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 wxMenuBar *result;
34209 PyObject * obj0 = 0 ;
34210 char *kwnames[] = {
34211 (char *) "self", NULL
34212 };
34213
34214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34216 if (SWIG_arg_fail(1)) SWIG_fail;
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34220
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = wxPyMake_wxObject(result, 0);
34226 }
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj;
34235 wxMenu *arg1 = (wxMenu *) 0 ;
34236 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 char *kwnames[] = {
34240 (char *) "self",(char *) "menubar", NULL
34241 };
34242
34243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34247 if (SWIG_arg_fail(2)) SWIG_fail;
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 (arg1)->Attach(arg2);
34251
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 Py_INCREF(Py_None); resultobj = Py_None;
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34263 PyObject *resultobj;
34264 wxMenu *arg1 = (wxMenu *) 0 ;
34265 PyObject * obj0 = 0 ;
34266 char *kwnames[] = {
34267 (char *) "self", NULL
34268 };
34269
34270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34272 if (SWIG_arg_fail(1)) SWIG_fail;
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 (arg1)->Detach();
34276
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 Py_INCREF(Py_None); resultobj = Py_None;
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34288 PyObject *resultobj;
34289 wxMenu *arg1 = (wxMenu *) 0 ;
34290 bool result;
34291 PyObject * obj0 = 0 ;
34292 char *kwnames[] = {
34293 (char *) "self", NULL
34294 };
34295
34296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34298 if (SWIG_arg_fail(1)) SWIG_fail;
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 result = (bool)((wxMenu const *)arg1)->IsAttached();
34302
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 {
34307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34308 }
34309 return resultobj;
34310 fail:
34311 return NULL;
34312 }
34313
34314
34315 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34316 PyObject *resultobj;
34317 wxMenu *arg1 = (wxMenu *) 0 ;
34318 wxMenu *arg2 = (wxMenu *) 0 ;
34319 PyObject * obj0 = 0 ;
34320 PyObject * obj1 = 0 ;
34321 char *kwnames[] = {
34322 (char *) "self",(char *) "parent", NULL
34323 };
34324
34325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34327 if (SWIG_arg_fail(1)) SWIG_fail;
34328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34329 if (SWIG_arg_fail(2)) SWIG_fail;
34330 {
34331 PyThreadState* __tstate = wxPyBeginAllowThreads();
34332 (arg1)->SetParent(arg2);
34333
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 Py_INCREF(Py_None); resultobj = Py_None;
34338 return resultobj;
34339 fail:
34340 return NULL;
34341 }
34342
34343
34344 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34345 PyObject *resultobj;
34346 wxMenu *arg1 = (wxMenu *) 0 ;
34347 wxMenu *result;
34348 PyObject * obj0 = 0 ;
34349 char *kwnames[] = {
34350 (char *) "self", NULL
34351 };
34352
34353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34355 if (SWIG_arg_fail(1)) SWIG_fail;
34356 {
34357 PyThreadState* __tstate = wxPyBeginAllowThreads();
34358 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34359
34360 wxPyEndAllowThreads(__tstate);
34361 if (PyErr_Occurred()) SWIG_fail;
34362 }
34363 {
34364 resultobj = wxPyMake_wxObject(result, 0);
34365 }
34366 return resultobj;
34367 fail:
34368 return NULL;
34369 }
34370
34371
34372 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34373 PyObject *obj;
34374 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34375 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34376 Py_INCREF(obj);
34377 return Py_BuildValue((char *)"");
34378 }
34379 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34380 PyObject *resultobj;
34381 long arg1 = (long) 0 ;
34382 wxMenuBar *result;
34383 PyObject * obj0 = 0 ;
34384 char *kwnames[] = {
34385 (char *) "style", NULL
34386 };
34387
34388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34389 if (obj0) {
34390 {
34391 arg1 = (long)(SWIG_As_long(obj0));
34392 if (SWIG_arg_fail(1)) SWIG_fail;
34393 }
34394 }
34395 {
34396 if (!wxPyCheckForApp()) SWIG_fail;
34397 PyThreadState* __tstate = wxPyBeginAllowThreads();
34398 result = (wxMenuBar *)new wxMenuBar(arg1);
34399
34400 wxPyEndAllowThreads(__tstate);
34401 if (PyErr_Occurred()) SWIG_fail;
34402 }
34403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34404 return resultobj;
34405 fail:
34406 return NULL;
34407 }
34408
34409
34410 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34411 PyObject *resultobj;
34412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34413 wxMenu *arg2 = (wxMenu *) 0 ;
34414 wxString *arg3 = 0 ;
34415 bool result;
34416 bool temp3 = false ;
34417 PyObject * obj0 = 0 ;
34418 PyObject * obj1 = 0 ;
34419 PyObject * obj2 = 0 ;
34420 char *kwnames[] = {
34421 (char *) "self",(char *) "menu",(char *) "title", NULL
34422 };
34423
34424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34426 if (SWIG_arg_fail(1)) SWIG_fail;
34427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34428 if (SWIG_arg_fail(2)) SWIG_fail;
34429 {
34430 arg3 = wxString_in_helper(obj2);
34431 if (arg3 == NULL) SWIG_fail;
34432 temp3 = true;
34433 }
34434 {
34435 PyThreadState* __tstate = wxPyBeginAllowThreads();
34436 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34437
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 {
34442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34443 }
34444 {
34445 if (temp3)
34446 delete arg3;
34447 }
34448 return resultobj;
34449 fail:
34450 {
34451 if (temp3)
34452 delete arg3;
34453 }
34454 return NULL;
34455 }
34456
34457
34458 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34459 PyObject *resultobj;
34460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34461 size_t arg2 ;
34462 wxMenu *arg3 = (wxMenu *) 0 ;
34463 wxString *arg4 = 0 ;
34464 bool result;
34465 bool temp4 = false ;
34466 PyObject * obj0 = 0 ;
34467 PyObject * obj1 = 0 ;
34468 PyObject * obj2 = 0 ;
34469 PyObject * obj3 = 0 ;
34470 char *kwnames[] = {
34471 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34472 };
34473
34474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34476 if (SWIG_arg_fail(1)) SWIG_fail;
34477 {
34478 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34479 if (SWIG_arg_fail(2)) SWIG_fail;
34480 }
34481 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34482 if (SWIG_arg_fail(3)) SWIG_fail;
34483 {
34484 arg4 = wxString_in_helper(obj3);
34485 if (arg4 == NULL) SWIG_fail;
34486 temp4 = true;
34487 }
34488 {
34489 PyThreadState* __tstate = wxPyBeginAllowThreads();
34490 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34491
34492 wxPyEndAllowThreads(__tstate);
34493 if (PyErr_Occurred()) SWIG_fail;
34494 }
34495 {
34496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34497 }
34498 {
34499 if (temp4)
34500 delete arg4;
34501 }
34502 return resultobj;
34503 fail:
34504 {
34505 if (temp4)
34506 delete arg4;
34507 }
34508 return NULL;
34509 }
34510
34511
34512 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34513 PyObject *resultobj;
34514 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34515 size_t result;
34516 PyObject * obj0 = 0 ;
34517 char *kwnames[] = {
34518 (char *) "self", NULL
34519 };
34520
34521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34523 if (SWIG_arg_fail(1)) SWIG_fail;
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34527
34528 wxPyEndAllowThreads(__tstate);
34529 if (PyErr_Occurred()) SWIG_fail;
34530 }
34531 {
34532 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34533 }
34534 return resultobj;
34535 fail:
34536 return NULL;
34537 }
34538
34539
34540 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34541 PyObject *resultobj;
34542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34543 size_t arg2 ;
34544 wxMenu *result;
34545 PyObject * obj0 = 0 ;
34546 PyObject * obj1 = 0 ;
34547 char *kwnames[] = {
34548 (char *) "self",(char *) "pos", NULL
34549 };
34550
34551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34553 if (SWIG_arg_fail(1)) SWIG_fail;
34554 {
34555 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34556 if (SWIG_arg_fail(2)) SWIG_fail;
34557 }
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34561
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 {
34566 resultobj = wxPyMake_wxObject(result, 0);
34567 }
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34575 PyObject *resultobj;
34576 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34577 size_t arg2 ;
34578 wxMenu *arg3 = (wxMenu *) 0 ;
34579 wxString *arg4 = 0 ;
34580 wxMenu *result;
34581 bool temp4 = false ;
34582 PyObject * obj0 = 0 ;
34583 PyObject * obj1 = 0 ;
34584 PyObject * obj2 = 0 ;
34585 PyObject * obj3 = 0 ;
34586 char *kwnames[] = {
34587 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34588 };
34589
34590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34592 if (SWIG_arg_fail(1)) SWIG_fail;
34593 {
34594 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34595 if (SWIG_arg_fail(2)) SWIG_fail;
34596 }
34597 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34598 if (SWIG_arg_fail(3)) SWIG_fail;
34599 {
34600 arg4 = wxString_in_helper(obj3);
34601 if (arg4 == NULL) SWIG_fail;
34602 temp4 = true;
34603 }
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34607
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 {
34612 resultobj = wxPyMake_wxObject(result, 0);
34613 }
34614 {
34615 if (temp4)
34616 delete arg4;
34617 }
34618 return resultobj;
34619 fail:
34620 {
34621 if (temp4)
34622 delete arg4;
34623 }
34624 return NULL;
34625 }
34626
34627
34628 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj;
34630 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34631 size_t arg2 ;
34632 wxMenu *result;
34633 PyObject * obj0 = 0 ;
34634 PyObject * obj1 = 0 ;
34635 char *kwnames[] = {
34636 (char *) "self",(char *) "pos", NULL
34637 };
34638
34639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34641 if (SWIG_arg_fail(1)) SWIG_fail;
34642 {
34643 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34644 if (SWIG_arg_fail(2)) SWIG_fail;
34645 }
34646 {
34647 PyThreadState* __tstate = wxPyBeginAllowThreads();
34648 result = (wxMenu *)(arg1)->Remove(arg2);
34649
34650 wxPyEndAllowThreads(__tstate);
34651 if (PyErr_Occurred()) SWIG_fail;
34652 }
34653 {
34654 resultobj = wxPyMake_wxObject(result, 0);
34655 }
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj;
34664 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34665 size_t arg2 ;
34666 bool arg3 ;
34667 PyObject * obj0 = 0 ;
34668 PyObject * obj1 = 0 ;
34669 PyObject * obj2 = 0 ;
34670 char *kwnames[] = {
34671 (char *) "self",(char *) "pos",(char *) "enable", NULL
34672 };
34673
34674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34676 if (SWIG_arg_fail(1)) SWIG_fail;
34677 {
34678 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34679 if (SWIG_arg_fail(2)) SWIG_fail;
34680 }
34681 {
34682 arg3 = (bool)(SWIG_As_bool(obj2));
34683 if (SWIG_arg_fail(3)) SWIG_fail;
34684 }
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 (arg1)->EnableTop(arg2,arg3);
34688
34689 wxPyEndAllowThreads(__tstate);
34690 if (PyErr_Occurred()) SWIG_fail;
34691 }
34692 Py_INCREF(Py_None); resultobj = Py_None;
34693 return resultobj;
34694 fail:
34695 return NULL;
34696 }
34697
34698
34699 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34700 PyObject *resultobj;
34701 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34702 size_t arg2 ;
34703 bool result;
34704 PyObject * obj0 = 0 ;
34705 PyObject * obj1 = 0 ;
34706 char *kwnames[] = {
34707 (char *) "self",(char *) "pos", NULL
34708 };
34709
34710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(1)) SWIG_fail;
34713 {
34714 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34715 if (SWIG_arg_fail(2)) SWIG_fail;
34716 }
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34720
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 {
34725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34726 }
34727 return resultobj;
34728 fail:
34729 return NULL;
34730 }
34731
34732
34733 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34734 PyObject *resultobj;
34735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34736 size_t arg2 ;
34737 wxString *arg3 = 0 ;
34738 bool temp3 = false ;
34739 PyObject * obj0 = 0 ;
34740 PyObject * obj1 = 0 ;
34741 PyObject * obj2 = 0 ;
34742 char *kwnames[] = {
34743 (char *) "self",(char *) "pos",(char *) "label", NULL
34744 };
34745
34746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34748 if (SWIG_arg_fail(1)) SWIG_fail;
34749 {
34750 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34751 if (SWIG_arg_fail(2)) SWIG_fail;
34752 }
34753 {
34754 arg3 = wxString_in_helper(obj2);
34755 if (arg3 == NULL) SWIG_fail;
34756 temp3 = true;
34757 }
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34761
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 Py_INCREF(Py_None); resultobj = Py_None;
34766 {
34767 if (temp3)
34768 delete arg3;
34769 }
34770 return resultobj;
34771 fail:
34772 {
34773 if (temp3)
34774 delete arg3;
34775 }
34776 return NULL;
34777 }
34778
34779
34780 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj;
34782 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34783 size_t arg2 ;
34784 wxString result;
34785 PyObject * obj0 = 0 ;
34786 PyObject * obj1 = 0 ;
34787 char *kwnames[] = {
34788 (char *) "self",(char *) "pos", NULL
34789 };
34790
34791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34793 if (SWIG_arg_fail(1)) SWIG_fail;
34794 {
34795 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34796 if (SWIG_arg_fail(2)) SWIG_fail;
34797 }
34798 {
34799 PyThreadState* __tstate = wxPyBeginAllowThreads();
34800 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34801
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 {
34806 #if wxUSE_UNICODE
34807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34808 #else
34809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34810 #endif
34811 }
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj;
34820 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34821 wxString *arg2 = 0 ;
34822 wxString *arg3 = 0 ;
34823 int result;
34824 bool temp2 = false ;
34825 bool temp3 = false ;
34826 PyObject * obj0 = 0 ;
34827 PyObject * obj1 = 0 ;
34828 PyObject * obj2 = 0 ;
34829 char *kwnames[] = {
34830 (char *) "self",(char *) "menu",(char *) "item", NULL
34831 };
34832
34833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34835 if (SWIG_arg_fail(1)) SWIG_fail;
34836 {
34837 arg2 = wxString_in_helper(obj1);
34838 if (arg2 == NULL) SWIG_fail;
34839 temp2 = true;
34840 }
34841 {
34842 arg3 = wxString_in_helper(obj2);
34843 if (arg3 == NULL) SWIG_fail;
34844 temp3 = true;
34845 }
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34849
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 {
34854 resultobj = SWIG_From_int((int)(result));
34855 }
34856 {
34857 if (temp2)
34858 delete arg2;
34859 }
34860 {
34861 if (temp3)
34862 delete arg3;
34863 }
34864 return resultobj;
34865 fail:
34866 {
34867 if (temp2)
34868 delete arg2;
34869 }
34870 {
34871 if (temp3)
34872 delete arg3;
34873 }
34874 return NULL;
34875 }
34876
34877
34878 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34879 PyObject *resultobj;
34880 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34881 int arg2 ;
34882 wxMenuItem *result;
34883 PyObject * obj0 = 0 ;
34884 PyObject * obj1 = 0 ;
34885 char *kwnames[] = {
34886 (char *) "self",(char *) "id", NULL
34887 };
34888
34889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34891 if (SWIG_arg_fail(1)) SWIG_fail;
34892 {
34893 arg2 = (int)(SWIG_As_int(obj1));
34894 if (SWIG_arg_fail(2)) SWIG_fail;
34895 }
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34899
34900 wxPyEndAllowThreads(__tstate);
34901 if (PyErr_Occurred()) SWIG_fail;
34902 }
34903 {
34904 resultobj = wxPyMake_wxObject(result, 0);
34905 }
34906 return resultobj;
34907 fail:
34908 return NULL;
34909 }
34910
34911
34912 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34913 PyObject *resultobj;
34914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34915 wxString *arg2 = 0 ;
34916 int result;
34917 bool temp2 = false ;
34918 PyObject * obj0 = 0 ;
34919 PyObject * obj1 = 0 ;
34920 char *kwnames[] = {
34921 (char *) "self",(char *) "title", NULL
34922 };
34923
34924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34926 if (SWIG_arg_fail(1)) SWIG_fail;
34927 {
34928 arg2 = wxString_in_helper(obj1);
34929 if (arg2 == NULL) SWIG_fail;
34930 temp2 = true;
34931 }
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34935
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 resultobj = SWIG_From_int((int)(result));
34941 }
34942 {
34943 if (temp2)
34944 delete arg2;
34945 }
34946 return resultobj;
34947 fail:
34948 {
34949 if (temp2)
34950 delete arg2;
34951 }
34952 return NULL;
34953 }
34954
34955
34956 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34957 PyObject *resultobj;
34958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34959 int arg2 ;
34960 bool arg3 ;
34961 PyObject * obj0 = 0 ;
34962 PyObject * obj1 = 0 ;
34963 PyObject * obj2 = 0 ;
34964 char *kwnames[] = {
34965 (char *) "self",(char *) "id",(char *) "enable", NULL
34966 };
34967
34968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34970 if (SWIG_arg_fail(1)) SWIG_fail;
34971 {
34972 arg2 = (int)(SWIG_As_int(obj1));
34973 if (SWIG_arg_fail(2)) SWIG_fail;
34974 }
34975 {
34976 arg3 = (bool)(SWIG_As_bool(obj2));
34977 if (SWIG_arg_fail(3)) SWIG_fail;
34978 }
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 (arg1)->Enable(arg2,arg3);
34982
34983 wxPyEndAllowThreads(__tstate);
34984 if (PyErr_Occurred()) SWIG_fail;
34985 }
34986 Py_INCREF(Py_None); resultobj = Py_None;
34987 return resultobj;
34988 fail:
34989 return NULL;
34990 }
34991
34992
34993 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj;
34995 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34996 int arg2 ;
34997 bool arg3 ;
34998 PyObject * obj0 = 0 ;
34999 PyObject * obj1 = 0 ;
35000 PyObject * obj2 = 0 ;
35001 char *kwnames[] = {
35002 (char *) "self",(char *) "id",(char *) "check", NULL
35003 };
35004
35005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35007 if (SWIG_arg_fail(1)) SWIG_fail;
35008 {
35009 arg2 = (int)(SWIG_As_int(obj1));
35010 if (SWIG_arg_fail(2)) SWIG_fail;
35011 }
35012 {
35013 arg3 = (bool)(SWIG_As_bool(obj2));
35014 if (SWIG_arg_fail(3)) SWIG_fail;
35015 }
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 (arg1)->Check(arg2,arg3);
35019
35020 wxPyEndAllowThreads(__tstate);
35021 if (PyErr_Occurred()) SWIG_fail;
35022 }
35023 Py_INCREF(Py_None); resultobj = Py_None;
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35031 PyObject *resultobj;
35032 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35033 int arg2 ;
35034 bool 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:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, 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 = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35051
35052 wxPyEndAllowThreads(__tstate);
35053 if (PyErr_Occurred()) SWIG_fail;
35054 }
35055 {
35056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35057 }
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35065 PyObject *resultobj;
35066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35067 int arg2 ;
35068 bool result;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char *kwnames[] = {
35072 (char *) "self",(char *) "id", NULL
35073 };
35074
35075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35077 if (SWIG_arg_fail(1)) SWIG_fail;
35078 {
35079 arg2 = (int)(SWIG_As_int(obj1));
35080 if (SWIG_arg_fail(2)) SWIG_fail;
35081 }
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35085
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 {
35090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35091 }
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj;
35100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35101 int arg2 ;
35102 wxString *arg3 = 0 ;
35103 bool temp3 = false ;
35104 PyObject * obj0 = 0 ;
35105 PyObject * obj1 = 0 ;
35106 PyObject * obj2 = 0 ;
35107 char *kwnames[] = {
35108 (char *) "self",(char *) "id",(char *) "label", NULL
35109 };
35110
35111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(1)) SWIG_fail;
35114 {
35115 arg2 = (int)(SWIG_As_int(obj1));
35116 if (SWIG_arg_fail(2)) SWIG_fail;
35117 }
35118 {
35119 arg3 = wxString_in_helper(obj2);
35120 if (arg3 == NULL) SWIG_fail;
35121 temp3 = true;
35122 }
35123 {
35124 PyThreadState* __tstate = wxPyBeginAllowThreads();
35125 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35126
35127 wxPyEndAllowThreads(__tstate);
35128 if (PyErr_Occurred()) SWIG_fail;
35129 }
35130 Py_INCREF(Py_None); resultobj = Py_None;
35131 {
35132 if (temp3)
35133 delete arg3;
35134 }
35135 return resultobj;
35136 fail:
35137 {
35138 if (temp3)
35139 delete arg3;
35140 }
35141 return NULL;
35142 }
35143
35144
35145 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35146 PyObject *resultobj;
35147 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35148 int arg2 ;
35149 wxString result;
35150 PyObject * obj0 = 0 ;
35151 PyObject * obj1 = 0 ;
35152 char *kwnames[] = {
35153 (char *) "self",(char *) "id", NULL
35154 };
35155
35156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35158 if (SWIG_arg_fail(1)) SWIG_fail;
35159 {
35160 arg2 = (int)(SWIG_As_int(obj1));
35161 if (SWIG_arg_fail(2)) SWIG_fail;
35162 }
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35166
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 {
35171 #if wxUSE_UNICODE
35172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35173 #else
35174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35175 #endif
35176 }
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35184 PyObject *resultobj;
35185 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35186 int arg2 ;
35187 wxString *arg3 = 0 ;
35188 bool temp3 = false ;
35189 PyObject * obj0 = 0 ;
35190 PyObject * obj1 = 0 ;
35191 PyObject * obj2 = 0 ;
35192 char *kwnames[] = {
35193 (char *) "self",(char *) "id",(char *) "helpString", NULL
35194 };
35195
35196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35198 if (SWIG_arg_fail(1)) SWIG_fail;
35199 {
35200 arg2 = (int)(SWIG_As_int(obj1));
35201 if (SWIG_arg_fail(2)) SWIG_fail;
35202 }
35203 {
35204 arg3 = wxString_in_helper(obj2);
35205 if (arg3 == NULL) SWIG_fail;
35206 temp3 = true;
35207 }
35208 {
35209 PyThreadState* __tstate = wxPyBeginAllowThreads();
35210 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35211
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 Py_INCREF(Py_None); resultobj = Py_None;
35216 {
35217 if (temp3)
35218 delete arg3;
35219 }
35220 return resultobj;
35221 fail:
35222 {
35223 if (temp3)
35224 delete arg3;
35225 }
35226 return NULL;
35227 }
35228
35229
35230 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35231 PyObject *resultobj;
35232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35233 int arg2 ;
35234 wxString result;
35235 PyObject * obj0 = 0 ;
35236 PyObject * obj1 = 0 ;
35237 char *kwnames[] = {
35238 (char *) "self",(char *) "id", NULL
35239 };
35240
35241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35243 if (SWIG_arg_fail(1)) SWIG_fail;
35244 {
35245 arg2 = (int)(SWIG_As_int(obj1));
35246 if (SWIG_arg_fail(2)) SWIG_fail;
35247 }
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35251
35252 wxPyEndAllowThreads(__tstate);
35253 if (PyErr_Occurred()) SWIG_fail;
35254 }
35255 {
35256 #if wxUSE_UNICODE
35257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35258 #else
35259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35260 #endif
35261 }
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35269 PyObject *resultobj;
35270 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35271 wxFrame *result;
35272 PyObject * obj0 = 0 ;
35273 char *kwnames[] = {
35274 (char *) "self", NULL
35275 };
35276
35277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35279 if (SWIG_arg_fail(1)) SWIG_fail;
35280 {
35281 PyThreadState* __tstate = wxPyBeginAllowThreads();
35282 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35283
35284 wxPyEndAllowThreads(__tstate);
35285 if (PyErr_Occurred()) SWIG_fail;
35286 }
35287 {
35288 resultobj = wxPyMake_wxObject(result, 0);
35289 }
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj;
35298 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35299 bool result;
35300 PyObject * obj0 = 0 ;
35301 char *kwnames[] = {
35302 (char *) "self", NULL
35303 };
35304
35305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35307 if (SWIG_arg_fail(1)) SWIG_fail;
35308 {
35309 PyThreadState* __tstate = wxPyBeginAllowThreads();
35310 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35311
35312 wxPyEndAllowThreads(__tstate);
35313 if (PyErr_Occurred()) SWIG_fail;
35314 }
35315 {
35316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35317 }
35318 return resultobj;
35319 fail:
35320 return NULL;
35321 }
35322
35323
35324 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35325 PyObject *resultobj;
35326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35327 wxFrame *arg2 = (wxFrame *) 0 ;
35328 PyObject * obj0 = 0 ;
35329 PyObject * obj1 = 0 ;
35330 char *kwnames[] = {
35331 (char *) "self",(char *) "frame", NULL
35332 };
35333
35334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35336 if (SWIG_arg_fail(1)) SWIG_fail;
35337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35338 if (SWIG_arg_fail(2)) SWIG_fail;
35339 {
35340 PyThreadState* __tstate = wxPyBeginAllowThreads();
35341 (arg1)->Attach(arg2);
35342
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 Py_INCREF(Py_None); resultobj = Py_None;
35347 return resultobj;
35348 fail:
35349 return NULL;
35350 }
35351
35352
35353 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35354 PyObject *resultobj;
35355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35356 PyObject * obj0 = 0 ;
35357 char *kwnames[] = {
35358 (char *) "self", NULL
35359 };
35360
35361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35363 if (SWIG_arg_fail(1)) SWIG_fail;
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 (arg1)->Detach();
35367
35368 wxPyEndAllowThreads(__tstate);
35369 if (PyErr_Occurred()) SWIG_fail;
35370 }
35371 Py_INCREF(Py_None); resultobj = Py_None;
35372 return resultobj;
35373 fail:
35374 return NULL;
35375 }
35376
35377
35378 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35379 PyObject *obj;
35380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35381 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35382 Py_INCREF(obj);
35383 return Py_BuildValue((char *)"");
35384 }
35385 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35386 PyObject *resultobj;
35387 wxMenu *arg1 = (wxMenu *) NULL ;
35388 int arg2 = (int) wxID_ANY ;
35389 wxString const &arg3_defvalue = wxPyEmptyString ;
35390 wxString *arg3 = (wxString *) &arg3_defvalue ;
35391 wxString const &arg4_defvalue = wxPyEmptyString ;
35392 wxString *arg4 = (wxString *) &arg4_defvalue ;
35393 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35394 wxMenu *arg6 = (wxMenu *) NULL ;
35395 wxMenuItem *result;
35396 bool temp3 = false ;
35397 bool temp4 = false ;
35398 PyObject * obj0 = 0 ;
35399 PyObject * obj1 = 0 ;
35400 PyObject * obj2 = 0 ;
35401 PyObject * obj3 = 0 ;
35402 PyObject * obj4 = 0 ;
35403 PyObject * obj5 = 0 ;
35404 char *kwnames[] = {
35405 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35406 };
35407
35408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35409 if (obj0) {
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 }
35413 if (obj1) {
35414 {
35415 arg2 = (int)(SWIG_As_int(obj1));
35416 if (SWIG_arg_fail(2)) SWIG_fail;
35417 }
35418 }
35419 if (obj2) {
35420 {
35421 arg3 = wxString_in_helper(obj2);
35422 if (arg3 == NULL) SWIG_fail;
35423 temp3 = true;
35424 }
35425 }
35426 if (obj3) {
35427 {
35428 arg4 = wxString_in_helper(obj3);
35429 if (arg4 == NULL) SWIG_fail;
35430 temp4 = true;
35431 }
35432 }
35433 if (obj4) {
35434 {
35435 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35436 if (SWIG_arg_fail(5)) SWIG_fail;
35437 }
35438 }
35439 if (obj5) {
35440 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35441 if (SWIG_arg_fail(6)) SWIG_fail;
35442 }
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35446
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 {
35451 resultobj = wxPyMake_wxObject(result, 1);
35452 }
35453 {
35454 if (temp3)
35455 delete arg3;
35456 }
35457 {
35458 if (temp4)
35459 delete arg4;
35460 }
35461 return resultobj;
35462 fail:
35463 {
35464 if (temp3)
35465 delete arg3;
35466 }
35467 {
35468 if (temp4)
35469 delete arg4;
35470 }
35471 return NULL;
35472 }
35473
35474
35475 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj;
35477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35478 wxMenu *result;
35479 PyObject * obj0 = 0 ;
35480 char *kwnames[] = {
35481 (char *) "self", NULL
35482 };
35483
35484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35486 if (SWIG_arg_fail(1)) SWIG_fail;
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35490
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 {
35495 resultobj = wxPyMake_wxObject(result, 0);
35496 }
35497 return resultobj;
35498 fail:
35499 return NULL;
35500 }
35501
35502
35503 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj;
35505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35506 wxMenu *arg2 = (wxMenu *) 0 ;
35507 PyObject * obj0 = 0 ;
35508 PyObject * obj1 = 0 ;
35509 char *kwnames[] = {
35510 (char *) "self",(char *) "menu", NULL
35511 };
35512
35513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35515 if (SWIG_arg_fail(1)) SWIG_fail;
35516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35517 if (SWIG_arg_fail(2)) SWIG_fail;
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 (arg1)->SetMenu(arg2);
35521
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 Py_INCREF(Py_None); resultobj = Py_None;
35526 return resultobj;
35527 fail:
35528 return NULL;
35529 }
35530
35531
35532 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35533 PyObject *resultobj;
35534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35535 int arg2 ;
35536 PyObject * obj0 = 0 ;
35537 PyObject * obj1 = 0 ;
35538 char *kwnames[] = {
35539 (char *) "self",(char *) "id", NULL
35540 };
35541
35542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35544 if (SWIG_arg_fail(1)) SWIG_fail;
35545 {
35546 arg2 = (int)(SWIG_As_int(obj1));
35547 if (SWIG_arg_fail(2)) SWIG_fail;
35548 }
35549 {
35550 PyThreadState* __tstate = wxPyBeginAllowThreads();
35551 (arg1)->SetId(arg2);
35552
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 Py_INCREF(Py_None); resultobj = Py_None;
35557 return resultobj;
35558 fail:
35559 return NULL;
35560 }
35561
35562
35563 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35564 PyObject *resultobj;
35565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35566 int result;
35567 PyObject * obj0 = 0 ;
35568 char *kwnames[] = {
35569 (char *) "self", NULL
35570 };
35571
35572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35574 if (SWIG_arg_fail(1)) SWIG_fail;
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (int)((wxMenuItem const *)arg1)->GetId();
35578
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 {
35583 resultobj = SWIG_From_int((int)(result));
35584 }
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35592 PyObject *resultobj;
35593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35594 bool result;
35595 PyObject * obj0 = 0 ;
35596 char *kwnames[] = {
35597 (char *) "self", NULL
35598 };
35599
35600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35602 if (SWIG_arg_fail(1)) SWIG_fail;
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35606
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 {
35611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35612 }
35613 return resultobj;
35614 fail:
35615 return NULL;
35616 }
35617
35618
35619 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35620 PyObject *resultobj;
35621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35622 wxString *arg2 = 0 ;
35623 bool temp2 = false ;
35624 PyObject * obj0 = 0 ;
35625 PyObject * obj1 = 0 ;
35626 char *kwnames[] = {
35627 (char *) "self",(char *) "str", NULL
35628 };
35629
35630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35632 if (SWIG_arg_fail(1)) SWIG_fail;
35633 {
35634 arg2 = wxString_in_helper(obj1);
35635 if (arg2 == NULL) SWIG_fail;
35636 temp2 = true;
35637 }
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 (arg1)->SetText((wxString const &)*arg2);
35641
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 Py_INCREF(Py_None); resultobj = Py_None;
35646 {
35647 if (temp2)
35648 delete arg2;
35649 }
35650 return resultobj;
35651 fail:
35652 {
35653 if (temp2)
35654 delete arg2;
35655 }
35656 return NULL;
35657 }
35658
35659
35660 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35661 PyObject *resultobj;
35662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35663 wxString result;
35664 PyObject * obj0 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 result = ((wxMenuItem const *)arg1)->GetLabel();
35675
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 {
35680 #if wxUSE_UNICODE
35681 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35682 #else
35683 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35684 #endif
35685 }
35686 return resultobj;
35687 fail:
35688 return NULL;
35689 }
35690
35691
35692 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35693 PyObject *resultobj;
35694 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35695 wxString *result;
35696 PyObject * obj0 = 0 ;
35697 char *kwnames[] = {
35698 (char *) "self", NULL
35699 };
35700
35701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35703 if (SWIG_arg_fail(1)) SWIG_fail;
35704 {
35705 PyThreadState* __tstate = wxPyBeginAllowThreads();
35706 {
35707 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35708 result = (wxString *) &_result_ref;
35709 }
35710
35711 wxPyEndAllowThreads(__tstate);
35712 if (PyErr_Occurred()) SWIG_fail;
35713 }
35714 {
35715 #if wxUSE_UNICODE
35716 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35717 #else
35718 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35719 #endif
35720 }
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35728 PyObject *resultobj;
35729 wxString *arg1 = 0 ;
35730 wxString result;
35731 bool temp1 = false ;
35732 PyObject * obj0 = 0 ;
35733 char *kwnames[] = {
35734 (char *) "text", NULL
35735 };
35736
35737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35738 {
35739 arg1 = wxString_in_helper(obj0);
35740 if (arg1 == NULL) SWIG_fail;
35741 temp1 = true;
35742 }
35743 {
35744 PyThreadState* __tstate = wxPyBeginAllowThreads();
35745 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35746
35747 wxPyEndAllowThreads(__tstate);
35748 if (PyErr_Occurred()) SWIG_fail;
35749 }
35750 {
35751 #if wxUSE_UNICODE
35752 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35753 #else
35754 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35755 #endif
35756 }
35757 {
35758 if (temp1)
35759 delete arg1;
35760 }
35761 return resultobj;
35762 fail:
35763 {
35764 if (temp1)
35765 delete arg1;
35766 }
35767 return NULL;
35768 }
35769
35770
35771 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj;
35773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35774 wxItemKind result;
35775 PyObject * obj0 = 0 ;
35776 char *kwnames[] = {
35777 (char *) "self", NULL
35778 };
35779
35780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35782 if (SWIG_arg_fail(1)) SWIG_fail;
35783 {
35784 PyThreadState* __tstate = wxPyBeginAllowThreads();
35785 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35786
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 resultobj = SWIG_From_int((result));
35791 return resultobj;
35792 fail:
35793 return NULL;
35794 }
35795
35796
35797 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35798 PyObject *resultobj;
35799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35800 wxItemKind arg2 ;
35801 PyObject * obj0 = 0 ;
35802 PyObject * obj1 = 0 ;
35803 char *kwnames[] = {
35804 (char *) "self",(char *) "kind", NULL
35805 };
35806
35807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35809 if (SWIG_arg_fail(1)) SWIG_fail;
35810 {
35811 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35812 if (SWIG_arg_fail(2)) SWIG_fail;
35813 }
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 (arg1)->SetKind((wxItemKind )arg2);
35817
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 Py_INCREF(Py_None); resultobj = Py_None;
35822 return resultobj;
35823 fail:
35824 return NULL;
35825 }
35826
35827
35828 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35829 PyObject *resultobj;
35830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35831 bool arg2 ;
35832 PyObject * obj0 = 0 ;
35833 PyObject * obj1 = 0 ;
35834 char *kwnames[] = {
35835 (char *) "self",(char *) "checkable", NULL
35836 };
35837
35838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35840 if (SWIG_arg_fail(1)) SWIG_fail;
35841 {
35842 arg2 = (bool)(SWIG_As_bool(obj1));
35843 if (SWIG_arg_fail(2)) SWIG_fail;
35844 }
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 (arg1)->SetCheckable(arg2);
35848
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 Py_INCREF(Py_None); resultobj = Py_None;
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35860 PyObject *resultobj;
35861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35862 bool result;
35863 PyObject * obj0 = 0 ;
35864 char *kwnames[] = {
35865 (char *) "self", NULL
35866 };
35867
35868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35870 if (SWIG_arg_fail(1)) SWIG_fail;
35871 {
35872 PyThreadState* __tstate = wxPyBeginAllowThreads();
35873 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35874
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 {
35879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35880 }
35881 return resultobj;
35882 fail:
35883 return NULL;
35884 }
35885
35886
35887 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35888 PyObject *resultobj;
35889 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35890 bool result;
35891 PyObject * obj0 = 0 ;
35892 char *kwnames[] = {
35893 (char *) "self", NULL
35894 };
35895
35896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35898 if (SWIG_arg_fail(1)) SWIG_fail;
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35902
35903 wxPyEndAllowThreads(__tstate);
35904 if (PyErr_Occurred()) SWIG_fail;
35905 }
35906 {
35907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35908 }
35909 return resultobj;
35910 fail:
35911 return NULL;
35912 }
35913
35914
35915 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35916 PyObject *resultobj;
35917 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35918 wxMenu *arg2 = (wxMenu *) 0 ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 char *kwnames[] = {
35922 (char *) "self",(char *) "menu", NULL
35923 };
35924
35925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35927 if (SWIG_arg_fail(1)) SWIG_fail;
35928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35929 if (SWIG_arg_fail(2)) SWIG_fail;
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 (arg1)->SetSubMenu(arg2);
35933
35934 wxPyEndAllowThreads(__tstate);
35935 if (PyErr_Occurred()) SWIG_fail;
35936 }
35937 Py_INCREF(Py_None); resultobj = Py_None;
35938 return resultobj;
35939 fail:
35940 return NULL;
35941 }
35942
35943
35944 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35945 PyObject *resultobj;
35946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35947 wxMenu *result;
35948 PyObject * obj0 = 0 ;
35949 char *kwnames[] = {
35950 (char *) "self", NULL
35951 };
35952
35953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(1)) SWIG_fail;
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35959
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 {
35964 resultobj = wxPyMake_wxObject(result, 0);
35965 }
35966 return resultobj;
35967 fail:
35968 return NULL;
35969 }
35970
35971
35972 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj;
35974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35975 bool arg2 = (bool) true ;
35976 PyObject * obj0 = 0 ;
35977 PyObject * obj1 = 0 ;
35978 char *kwnames[] = {
35979 (char *) "self",(char *) "enable", NULL
35980 };
35981
35982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35984 if (SWIG_arg_fail(1)) SWIG_fail;
35985 if (obj1) {
35986 {
35987 arg2 = (bool)(SWIG_As_bool(obj1));
35988 if (SWIG_arg_fail(2)) SWIG_fail;
35989 }
35990 }
35991 {
35992 PyThreadState* __tstate = wxPyBeginAllowThreads();
35993 (arg1)->Enable(arg2);
35994
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 Py_INCREF(Py_None); resultobj = Py_None;
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36006 PyObject *resultobj;
36007 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36008 bool result;
36009 PyObject * obj0 = 0 ;
36010 char *kwnames[] = {
36011 (char *) "self", NULL
36012 };
36013
36014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36016 if (SWIG_arg_fail(1)) SWIG_fail;
36017 {
36018 PyThreadState* __tstate = wxPyBeginAllowThreads();
36019 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36020
36021 wxPyEndAllowThreads(__tstate);
36022 if (PyErr_Occurred()) SWIG_fail;
36023 }
36024 {
36025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36026 }
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36036 bool arg2 = (bool) true ;
36037 PyObject * obj0 = 0 ;
36038 PyObject * obj1 = 0 ;
36039 char *kwnames[] = {
36040 (char *) "self",(char *) "check", NULL
36041 };
36042
36043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36045 if (SWIG_arg_fail(1)) SWIG_fail;
36046 if (obj1) {
36047 {
36048 arg2 = (bool)(SWIG_As_bool(obj1));
36049 if (SWIG_arg_fail(2)) SWIG_fail;
36050 }
36051 }
36052 {
36053 PyThreadState* __tstate = wxPyBeginAllowThreads();
36054 (arg1)->Check(arg2);
36055
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 Py_INCREF(Py_None); resultobj = Py_None;
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36067 PyObject *resultobj;
36068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36069 bool result;
36070 PyObject * obj0 = 0 ;
36071 char *kwnames[] = {
36072 (char *) "self", NULL
36073 };
36074
36075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36077 if (SWIG_arg_fail(1)) SWIG_fail;
36078 {
36079 PyThreadState* __tstate = wxPyBeginAllowThreads();
36080 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36081
36082 wxPyEndAllowThreads(__tstate);
36083 if (PyErr_Occurred()) SWIG_fail;
36084 }
36085 {
36086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36087 }
36088 return resultobj;
36089 fail:
36090 return NULL;
36091 }
36092
36093
36094 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36095 PyObject *resultobj;
36096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36097 PyObject * obj0 = 0 ;
36098 char *kwnames[] = {
36099 (char *) "self", NULL
36100 };
36101
36102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36104 if (SWIG_arg_fail(1)) SWIG_fail;
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 (arg1)->Toggle();
36108
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 Py_INCREF(Py_None); resultobj = Py_None;
36113 return resultobj;
36114 fail:
36115 return NULL;
36116 }
36117
36118
36119 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36120 PyObject *resultobj;
36121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36122 wxString *arg2 = 0 ;
36123 bool temp2 = false ;
36124 PyObject * obj0 = 0 ;
36125 PyObject * obj1 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self",(char *) "str", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 arg2 = wxString_in_helper(obj1);
36135 if (arg2 == NULL) SWIG_fail;
36136 temp2 = true;
36137 }
36138 {
36139 PyThreadState* __tstate = wxPyBeginAllowThreads();
36140 (arg1)->SetHelp((wxString const &)*arg2);
36141
36142 wxPyEndAllowThreads(__tstate);
36143 if (PyErr_Occurred()) SWIG_fail;
36144 }
36145 Py_INCREF(Py_None); resultobj = Py_None;
36146 {
36147 if (temp2)
36148 delete arg2;
36149 }
36150 return resultobj;
36151 fail:
36152 {
36153 if (temp2)
36154 delete arg2;
36155 }
36156 return NULL;
36157 }
36158
36159
36160 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj;
36162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36163 wxString *result;
36164 PyObject * obj0 = 0 ;
36165 char *kwnames[] = {
36166 (char *) "self", NULL
36167 };
36168
36169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36171 if (SWIG_arg_fail(1)) SWIG_fail;
36172 {
36173 PyThreadState* __tstate = wxPyBeginAllowThreads();
36174 {
36175 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36176 result = (wxString *) &_result_ref;
36177 }
36178
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 {
36183 #if wxUSE_UNICODE
36184 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36185 #else
36186 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36187 #endif
36188 }
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36196 PyObject *resultobj;
36197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36198 wxAcceleratorEntry *result;
36199 PyObject * obj0 = 0 ;
36200 char *kwnames[] = {
36201 (char *) "self", NULL
36202 };
36203
36204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36206 if (SWIG_arg_fail(1)) SWIG_fail;
36207 {
36208 PyThreadState* __tstate = wxPyBeginAllowThreads();
36209 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36210
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36222 PyObject *resultobj;
36223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36224 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36225 PyObject * obj0 = 0 ;
36226 PyObject * obj1 = 0 ;
36227 char *kwnames[] = {
36228 (char *) "self",(char *) "accel", NULL
36229 };
36230
36231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36233 if (SWIG_arg_fail(1)) SWIG_fail;
36234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36235 if (SWIG_arg_fail(2)) SWIG_fail;
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 (arg1)->SetAccel(arg2);
36239
36240 wxPyEndAllowThreads(__tstate);
36241 if (PyErr_Occurred()) SWIG_fail;
36242 }
36243 Py_INCREF(Py_None); resultobj = Py_None;
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36253 wxFont *arg2 = 0 ;
36254 PyObject * obj0 = 0 ;
36255 PyObject * obj1 = 0 ;
36256 char *kwnames[] = {
36257 (char *) "self",(char *) "font", NULL
36258 };
36259
36260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36262 if (SWIG_arg_fail(1)) SWIG_fail;
36263 {
36264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36265 if (SWIG_arg_fail(2)) SWIG_fail;
36266 if (arg2 == NULL) {
36267 SWIG_null_ref("wxFont");
36268 }
36269 if (SWIG_arg_fail(2)) SWIG_fail;
36270 }
36271 {
36272 PyThreadState* __tstate = wxPyBeginAllowThreads();
36273 (arg1)->SetFont((wxFont const &)*arg2);
36274
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 Py_INCREF(Py_None); resultobj = Py_None;
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36288 wxFont result;
36289 PyObject * obj0 = 0 ;
36290 char *kwnames[] = {
36291 (char *) "self", NULL
36292 };
36293
36294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36296 if (SWIG_arg_fail(1)) SWIG_fail;
36297 {
36298 PyThreadState* __tstate = wxPyBeginAllowThreads();
36299 result = (arg1)->GetFont();
36300
36301 wxPyEndAllowThreads(__tstate);
36302 if (PyErr_Occurred()) SWIG_fail;
36303 }
36304 {
36305 wxFont * resultptr;
36306 resultptr = new wxFont((wxFont &)(result));
36307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36308 }
36309 return resultobj;
36310 fail:
36311 return NULL;
36312 }
36313
36314
36315 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36316 PyObject *resultobj;
36317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36318 wxColour *arg2 = 0 ;
36319 wxColour temp2 ;
36320 PyObject * obj0 = 0 ;
36321 PyObject * obj1 = 0 ;
36322 char *kwnames[] = {
36323 (char *) "self",(char *) "colText", NULL
36324 };
36325
36326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36328 if (SWIG_arg_fail(1)) SWIG_fail;
36329 {
36330 arg2 = &temp2;
36331 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36332 }
36333 {
36334 PyThreadState* __tstate = wxPyBeginAllowThreads();
36335 (arg1)->SetTextColour((wxColour const &)*arg2);
36336
36337 wxPyEndAllowThreads(__tstate);
36338 if (PyErr_Occurred()) SWIG_fail;
36339 }
36340 Py_INCREF(Py_None); resultobj = Py_None;
36341 return resultobj;
36342 fail:
36343 return NULL;
36344 }
36345
36346
36347 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36348 PyObject *resultobj;
36349 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36350 wxColour result;
36351 PyObject * obj0 = 0 ;
36352 char *kwnames[] = {
36353 (char *) "self", NULL
36354 };
36355
36356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36358 if (SWIG_arg_fail(1)) SWIG_fail;
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (arg1)->GetTextColour();
36362
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 {
36367 wxColour * resultptr;
36368 resultptr = new wxColour((wxColour &)(result));
36369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36370 }
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj;
36379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36380 wxColour *arg2 = 0 ;
36381 wxColour temp2 ;
36382 PyObject * obj0 = 0 ;
36383 PyObject * obj1 = 0 ;
36384 char *kwnames[] = {
36385 (char *) "self",(char *) "colBack", NULL
36386 };
36387
36388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36390 if (SWIG_arg_fail(1)) SWIG_fail;
36391 {
36392 arg2 = &temp2;
36393 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36394 }
36395 {
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36398
36399 wxPyEndAllowThreads(__tstate);
36400 if (PyErr_Occurred()) SWIG_fail;
36401 }
36402 Py_INCREF(Py_None); resultobj = Py_None;
36403 return resultobj;
36404 fail:
36405 return NULL;
36406 }
36407
36408
36409 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36410 PyObject *resultobj;
36411 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36412 wxColour result;
36413 PyObject * obj0 = 0 ;
36414 char *kwnames[] = {
36415 (char *) "self", NULL
36416 };
36417
36418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36420 if (SWIG_arg_fail(1)) SWIG_fail;
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (arg1)->GetBackgroundColour();
36424
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 wxColour * resultptr;
36430 resultptr = new wxColour((wxColour &)(result));
36431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36432 }
36433 return resultobj;
36434 fail:
36435 return NULL;
36436 }
36437
36438
36439 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36440 PyObject *resultobj;
36441 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36442 wxBitmap *arg2 = 0 ;
36443 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36444 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36445 PyObject * obj0 = 0 ;
36446 PyObject * obj1 = 0 ;
36447 PyObject * obj2 = 0 ;
36448 char *kwnames[] = {
36449 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36450 };
36451
36452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36454 if (SWIG_arg_fail(1)) SWIG_fail;
36455 {
36456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36457 if (SWIG_arg_fail(2)) SWIG_fail;
36458 if (arg2 == NULL) {
36459 SWIG_null_ref("wxBitmap");
36460 }
36461 if (SWIG_arg_fail(2)) SWIG_fail;
36462 }
36463 if (obj2) {
36464 {
36465 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36466 if (SWIG_arg_fail(3)) SWIG_fail;
36467 if (arg3 == NULL) {
36468 SWIG_null_ref("wxBitmap");
36469 }
36470 if (SWIG_arg_fail(3)) SWIG_fail;
36471 }
36472 }
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
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_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36490 wxBitmap *arg2 = 0 ;
36491 PyObject * obj0 = 0 ;
36492 PyObject * obj1 = 0 ;
36493 char *kwnames[] = {
36494 (char *) "self",(char *) "bmpDisabled", NULL
36495 };
36496
36497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36499 if (SWIG_arg_fail(1)) SWIG_fail;
36500 {
36501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36502 if (SWIG_arg_fail(2)) SWIG_fail;
36503 if (arg2 == NULL) {
36504 SWIG_null_ref("wxBitmap");
36505 }
36506 if (SWIG_arg_fail(2)) SWIG_fail;
36507 }
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
36511
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 Py_INCREF(Py_None); resultobj = Py_None;
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36523 PyObject *resultobj;
36524 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36525 wxBitmap *result;
36526 PyObject * obj0 = 0 ;
36527 char *kwnames[] = {
36528 (char *) "self", NULL
36529 };
36530
36531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36533 if (SWIG_arg_fail(1)) SWIG_fail;
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 {
36537 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
36538 result = (wxBitmap *) &_result_ref;
36539 }
36540
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 {
36545 wxBitmap* resultptr = new wxBitmap(*result);
36546 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36547 }
36548 return resultobj;
36549 fail:
36550 return NULL;
36551 }
36552
36553
36554 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36555 PyObject *resultobj;
36556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36557 int arg2 ;
36558 PyObject * obj0 = 0 ;
36559 PyObject * obj1 = 0 ;
36560 char *kwnames[] = {
36561 (char *) "self",(char *) "nWidth", NULL
36562 };
36563
36564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36566 if (SWIG_arg_fail(1)) SWIG_fail;
36567 {
36568 arg2 = (int)(SWIG_As_int(obj1));
36569 if (SWIG_arg_fail(2)) SWIG_fail;
36570 }
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 (arg1)->SetMarginWidth(arg2);
36574
36575 wxPyEndAllowThreads(__tstate);
36576 if (PyErr_Occurred()) SWIG_fail;
36577 }
36578 Py_INCREF(Py_None); resultobj = Py_None;
36579 return resultobj;
36580 fail:
36581 return NULL;
36582 }
36583
36584
36585 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36586 PyObject *resultobj;
36587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36588 int result;
36589 PyObject * obj0 = 0 ;
36590 char *kwnames[] = {
36591 (char *) "self", NULL
36592 };
36593
36594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36596 if (SWIG_arg_fail(1)) SWIG_fail;
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (int)(arg1)->GetMarginWidth();
36600
36601 wxPyEndAllowThreads(__tstate);
36602 if (PyErr_Occurred()) SWIG_fail;
36603 }
36604 {
36605 resultobj = SWIG_From_int((int)(result));
36606 }
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36614 PyObject *resultobj;
36615 int result;
36616 char *kwnames[] = {
36617 NULL
36618 };
36619
36620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 result = (int)wxMenuItem::GetDefaultMarginWidth();
36624
36625 wxPyEndAllowThreads(__tstate);
36626 if (PyErr_Occurred()) SWIG_fail;
36627 }
36628 {
36629 resultobj = SWIG_From_int((int)(result));
36630 }
36631 return resultobj;
36632 fail:
36633 return NULL;
36634 }
36635
36636
36637 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36638 PyObject *resultobj;
36639 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36640 bool result;
36641 PyObject * obj0 = 0 ;
36642 char *kwnames[] = {
36643 (char *) "self", NULL
36644 };
36645
36646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36648 if (SWIG_arg_fail(1)) SWIG_fail;
36649 {
36650 PyThreadState* __tstate = wxPyBeginAllowThreads();
36651 result = (bool)(arg1)->IsOwnerDrawn();
36652
36653 wxPyEndAllowThreads(__tstate);
36654 if (PyErr_Occurred()) SWIG_fail;
36655 }
36656 {
36657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36658 }
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj;
36667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36668 bool arg2 = (bool) true ;
36669 PyObject * obj0 = 0 ;
36670 PyObject * obj1 = 0 ;
36671 char *kwnames[] = {
36672 (char *) "self",(char *) "ownerDrawn", NULL
36673 };
36674
36675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36677 if (SWIG_arg_fail(1)) SWIG_fail;
36678 if (obj1) {
36679 {
36680 arg2 = (bool)(SWIG_As_bool(obj1));
36681 if (SWIG_arg_fail(2)) SWIG_fail;
36682 }
36683 }
36684 {
36685 PyThreadState* __tstate = wxPyBeginAllowThreads();
36686 (arg1)->SetOwnerDrawn(arg2);
36687
36688 wxPyEndAllowThreads(__tstate);
36689 if (PyErr_Occurred()) SWIG_fail;
36690 }
36691 Py_INCREF(Py_None); resultobj = Py_None;
36692 return resultobj;
36693 fail:
36694 return NULL;
36695 }
36696
36697
36698 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36699 PyObject *resultobj;
36700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36701 PyObject * obj0 = 0 ;
36702 char *kwnames[] = {
36703 (char *) "self", NULL
36704 };
36705
36706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36708 if (SWIG_arg_fail(1)) SWIG_fail;
36709 {
36710 PyThreadState* __tstate = wxPyBeginAllowThreads();
36711 (arg1)->ResetOwnerDrawn();
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_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj;
36725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36726 wxBitmap *arg2 = 0 ;
36727 PyObject * obj0 = 0 ;
36728 PyObject * obj1 = 0 ;
36729 char *kwnames[] = {
36730 (char *) "self",(char *) "bitmap", NULL
36731 };
36732
36733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36735 if (SWIG_arg_fail(1)) SWIG_fail;
36736 {
36737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36738 if (SWIG_arg_fail(2)) SWIG_fail;
36739 if (arg2 == NULL) {
36740 SWIG_null_ref("wxBitmap");
36741 }
36742 if (SWIG_arg_fail(2)) SWIG_fail;
36743 }
36744 {
36745 PyThreadState* __tstate = wxPyBeginAllowThreads();
36746 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36747
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 Py_INCREF(Py_None); resultobj = Py_None;
36752 return resultobj;
36753 fail:
36754 return NULL;
36755 }
36756
36757
36758 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj;
36760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36761 wxBitmap *result;
36762 PyObject * obj0 = 0 ;
36763 char *kwnames[] = {
36764 (char *) "self", NULL
36765 };
36766
36767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36769 if (SWIG_arg_fail(1)) SWIG_fail;
36770 {
36771 PyThreadState* __tstate = wxPyBeginAllowThreads();
36772 {
36773 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36774 result = (wxBitmap *) &_result_ref;
36775 }
36776
36777 wxPyEndAllowThreads(__tstate);
36778 if (PyErr_Occurred()) SWIG_fail;
36779 }
36780 {
36781 wxBitmap* resultptr = new wxBitmap(*result);
36782 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36783 }
36784 return resultobj;
36785 fail:
36786 return NULL;
36787 }
36788
36789
36790 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36791 PyObject *obj;
36792 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36793 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36794 Py_INCREF(obj);
36795 return Py_BuildValue((char *)"");
36796 }
36797 static int _wrap_ControlNameStr_set(PyObject *) {
36798 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36799 return 1;
36800 }
36801
36802
36803 static PyObject *_wrap_ControlNameStr_get(void) {
36804 PyObject *pyobj;
36805
36806 {
36807 #if wxUSE_UNICODE
36808 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36809 #else
36810 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36811 #endif
36812 }
36813 return pyobj;
36814 }
36815
36816
36817 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36818 PyObject *resultobj;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 int arg2 = (int) -1 ;
36821 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36822 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36823 wxSize const &arg4_defvalue = wxDefaultSize ;
36824 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36825 long arg5 = (long) 0 ;
36826 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36827 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36828 wxString const &arg7_defvalue = wxPyControlNameStr ;
36829 wxString *arg7 = (wxString *) &arg7_defvalue ;
36830 wxControl *result;
36831 wxPoint temp3 ;
36832 wxSize temp4 ;
36833 bool temp7 = false ;
36834 PyObject * obj0 = 0 ;
36835 PyObject * obj1 = 0 ;
36836 PyObject * obj2 = 0 ;
36837 PyObject * obj3 = 0 ;
36838 PyObject * obj4 = 0 ;
36839 PyObject * obj5 = 0 ;
36840 PyObject * obj6 = 0 ;
36841 char *kwnames[] = {
36842 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36843 };
36844
36845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36847 if (SWIG_arg_fail(1)) SWIG_fail;
36848 if (obj1) {
36849 {
36850 arg2 = (int)(SWIG_As_int(obj1));
36851 if (SWIG_arg_fail(2)) SWIG_fail;
36852 }
36853 }
36854 if (obj2) {
36855 {
36856 arg3 = &temp3;
36857 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36858 }
36859 }
36860 if (obj3) {
36861 {
36862 arg4 = &temp4;
36863 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36864 }
36865 }
36866 if (obj4) {
36867 {
36868 arg5 = (long)(SWIG_As_long(obj4));
36869 if (SWIG_arg_fail(5)) SWIG_fail;
36870 }
36871 }
36872 if (obj5) {
36873 {
36874 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36875 if (SWIG_arg_fail(6)) SWIG_fail;
36876 if (arg6 == NULL) {
36877 SWIG_null_ref("wxValidator");
36878 }
36879 if (SWIG_arg_fail(6)) SWIG_fail;
36880 }
36881 }
36882 if (obj6) {
36883 {
36884 arg7 = wxString_in_helper(obj6);
36885 if (arg7 == NULL) SWIG_fail;
36886 temp7 = true;
36887 }
36888 }
36889 {
36890 if (!wxPyCheckForApp()) SWIG_fail;
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36893
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36898 {
36899 if (temp7)
36900 delete arg7;
36901 }
36902 return resultobj;
36903 fail:
36904 {
36905 if (temp7)
36906 delete arg7;
36907 }
36908 return NULL;
36909 }
36910
36911
36912 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36913 PyObject *resultobj;
36914 wxControl *result;
36915 char *kwnames[] = {
36916 NULL
36917 };
36918
36919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36920 {
36921 if (!wxPyCheckForApp()) SWIG_fail;
36922 PyThreadState* __tstate = wxPyBeginAllowThreads();
36923 result = (wxControl *)new wxControl();
36924
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj;
36937 wxControl *arg1 = (wxControl *) 0 ;
36938 wxWindow *arg2 = (wxWindow *) 0 ;
36939 int arg3 = (int) -1 ;
36940 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36941 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36942 wxSize const &arg5_defvalue = wxDefaultSize ;
36943 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36944 long arg6 = (long) 0 ;
36945 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36946 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36947 wxString const &arg8_defvalue = wxPyControlNameStr ;
36948 wxString *arg8 = (wxString *) &arg8_defvalue ;
36949 bool result;
36950 wxPoint temp4 ;
36951 wxSize temp5 ;
36952 bool temp8 = false ;
36953 PyObject * obj0 = 0 ;
36954 PyObject * obj1 = 0 ;
36955 PyObject * obj2 = 0 ;
36956 PyObject * obj3 = 0 ;
36957 PyObject * obj4 = 0 ;
36958 PyObject * obj5 = 0 ;
36959 PyObject * obj6 = 0 ;
36960 PyObject * obj7 = 0 ;
36961 char *kwnames[] = {
36962 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36963 };
36964
36965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36967 if (SWIG_arg_fail(1)) SWIG_fail;
36968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36969 if (SWIG_arg_fail(2)) SWIG_fail;
36970 if (obj2) {
36971 {
36972 arg3 = (int)(SWIG_As_int(obj2));
36973 if (SWIG_arg_fail(3)) SWIG_fail;
36974 }
36975 }
36976 if (obj3) {
36977 {
36978 arg4 = &temp4;
36979 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36980 }
36981 }
36982 if (obj4) {
36983 {
36984 arg5 = &temp5;
36985 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36986 }
36987 }
36988 if (obj5) {
36989 {
36990 arg6 = (long)(SWIG_As_long(obj5));
36991 if (SWIG_arg_fail(6)) SWIG_fail;
36992 }
36993 }
36994 if (obj6) {
36995 {
36996 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36997 if (SWIG_arg_fail(7)) SWIG_fail;
36998 if (arg7 == NULL) {
36999 SWIG_null_ref("wxValidator");
37000 }
37001 if (SWIG_arg_fail(7)) SWIG_fail;
37002 }
37003 }
37004 if (obj7) {
37005 {
37006 arg8 = wxString_in_helper(obj7);
37007 if (arg8 == NULL) SWIG_fail;
37008 temp8 = true;
37009 }
37010 }
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37014
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 {
37019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37020 }
37021 {
37022 if (temp8)
37023 delete arg8;
37024 }
37025 return resultobj;
37026 fail:
37027 {
37028 if (temp8)
37029 delete arg8;
37030 }
37031 return NULL;
37032 }
37033
37034
37035 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj;
37037 wxControl *arg1 = (wxControl *) 0 ;
37038 wxCommandEvent *arg2 = 0 ;
37039 PyObject * obj0 = 0 ;
37040 PyObject * obj1 = 0 ;
37041 char *kwnames[] = {
37042 (char *) "self",(char *) "event", NULL
37043 };
37044
37045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37047 if (SWIG_arg_fail(1)) SWIG_fail;
37048 {
37049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37050 if (SWIG_arg_fail(2)) SWIG_fail;
37051 if (arg2 == NULL) {
37052 SWIG_null_ref("wxCommandEvent");
37053 }
37054 if (SWIG_arg_fail(2)) SWIG_fail;
37055 }
37056 {
37057 PyThreadState* __tstate = wxPyBeginAllowThreads();
37058 (arg1)->Command(*arg2);
37059
37060 wxPyEndAllowThreads(__tstate);
37061 if (PyErr_Occurred()) SWIG_fail;
37062 }
37063 Py_INCREF(Py_None); resultobj = Py_None;
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj;
37072 wxControl *arg1 = (wxControl *) 0 ;
37073 wxString result;
37074 PyObject * obj0 = 0 ;
37075 char *kwnames[] = {
37076 (char *) "self", NULL
37077 };
37078
37079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37081 if (SWIG_arg_fail(1)) SWIG_fail;
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 result = (arg1)->GetLabel();
37085
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 {
37090 #if wxUSE_UNICODE
37091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37092 #else
37093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37094 #endif
37095 }
37096 return resultobj;
37097 fail:
37098 return NULL;
37099 }
37100
37101
37102 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37103 PyObject *resultobj;
37104 wxControl *arg1 = (wxControl *) 0 ;
37105 wxString *arg2 = 0 ;
37106 bool temp2 = false ;
37107 PyObject * obj0 = 0 ;
37108 PyObject * obj1 = 0 ;
37109 char *kwnames[] = {
37110 (char *) "self",(char *) "label", NULL
37111 };
37112
37113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37115 if (SWIG_arg_fail(1)) SWIG_fail;
37116 {
37117 arg2 = wxString_in_helper(obj1);
37118 if (arg2 == NULL) SWIG_fail;
37119 temp2 = true;
37120 }
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 (arg1)->SetLabel((wxString const &)*arg2);
37124
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 Py_INCREF(Py_None); resultobj = Py_None;
37129 {
37130 if (temp2)
37131 delete arg2;
37132 }
37133 return resultobj;
37134 fail:
37135 {
37136 if (temp2)
37137 delete arg2;
37138 }
37139 return NULL;
37140 }
37141
37142
37143 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj;
37145 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37146 wxVisualAttributes result;
37147 PyObject * obj0 = 0 ;
37148 char *kwnames[] = {
37149 (char *) "variant", NULL
37150 };
37151
37152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37153 if (obj0) {
37154 {
37155 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37156 if (SWIG_arg_fail(1)) SWIG_fail;
37157 }
37158 }
37159 {
37160 if (!wxPyCheckForApp()) SWIG_fail;
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37163
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 {
37168 wxVisualAttributes * resultptr;
37169 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37171 }
37172 return resultobj;
37173 fail:
37174 return NULL;
37175 }
37176
37177
37178 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37179 PyObject *obj;
37180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37181 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37182 Py_INCREF(obj);
37183 return Py_BuildValue((char *)"");
37184 }
37185 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37186 PyObject *resultobj;
37187 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37188 wxString *arg2 = 0 ;
37189 PyObject *arg3 = (PyObject *) NULL ;
37190 int result;
37191 bool temp2 = false ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 PyObject * obj2 = 0 ;
37195 char *kwnames[] = {
37196 (char *) "self",(char *) "item",(char *) "clientData", NULL
37197 };
37198
37199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37201 if (SWIG_arg_fail(1)) SWIG_fail;
37202 {
37203 arg2 = wxString_in_helper(obj1);
37204 if (arg2 == NULL) SWIG_fail;
37205 temp2 = true;
37206 }
37207 if (obj2) {
37208 arg3 = obj2;
37209 }
37210 {
37211 PyThreadState* __tstate = wxPyBeginAllowThreads();
37212 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37213
37214 wxPyEndAllowThreads(__tstate);
37215 if (PyErr_Occurred()) SWIG_fail;
37216 }
37217 {
37218 resultobj = SWIG_From_int((int)(result));
37219 }
37220 {
37221 if (temp2)
37222 delete arg2;
37223 }
37224 return resultobj;
37225 fail:
37226 {
37227 if (temp2)
37228 delete arg2;
37229 }
37230 return NULL;
37231 }
37232
37233
37234 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37235 PyObject *resultobj;
37236 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37237 wxArrayString *arg2 = 0 ;
37238 bool temp2 = false ;
37239 PyObject * obj0 = 0 ;
37240 PyObject * obj1 = 0 ;
37241 char *kwnames[] = {
37242 (char *) "self",(char *) "strings", NULL
37243 };
37244
37245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37247 if (SWIG_arg_fail(1)) SWIG_fail;
37248 {
37249 if (! PySequence_Check(obj1)) {
37250 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37251 SWIG_fail;
37252 }
37253 arg2 = new wxArrayString;
37254 temp2 = true;
37255 int i, len=PySequence_Length(obj1);
37256 for (i=0; i<len; i++) {
37257 PyObject* item = PySequence_GetItem(obj1, i);
37258 #if wxUSE_UNICODE
37259 PyObject* str = PyObject_Unicode(item);
37260 #else
37261 PyObject* str = PyObject_Str(item);
37262 #endif
37263 if (PyErr_Occurred()) SWIG_fail;
37264 arg2->Add(Py2wxString(str));
37265 Py_DECREF(item);
37266 Py_DECREF(str);
37267 }
37268 }
37269 {
37270 PyThreadState* __tstate = wxPyBeginAllowThreads();
37271 (arg1)->Append((wxArrayString const &)*arg2);
37272
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 Py_INCREF(Py_None); resultobj = Py_None;
37277 {
37278 if (temp2) delete arg2;
37279 }
37280 return resultobj;
37281 fail:
37282 {
37283 if (temp2) delete arg2;
37284 }
37285 return NULL;
37286 }
37287
37288
37289 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37290 PyObject *resultobj;
37291 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37292 wxString *arg2 = 0 ;
37293 int arg3 ;
37294 PyObject *arg4 = (PyObject *) NULL ;
37295 int result;
37296 bool temp2 = false ;
37297 PyObject * obj0 = 0 ;
37298 PyObject * obj1 = 0 ;
37299 PyObject * obj2 = 0 ;
37300 PyObject * obj3 = 0 ;
37301 char *kwnames[] = {
37302 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37303 };
37304
37305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37307 if (SWIG_arg_fail(1)) SWIG_fail;
37308 {
37309 arg2 = wxString_in_helper(obj1);
37310 if (arg2 == NULL) SWIG_fail;
37311 temp2 = true;
37312 }
37313 {
37314 arg3 = (int)(SWIG_As_int(obj2));
37315 if (SWIG_arg_fail(3)) SWIG_fail;
37316 }
37317 if (obj3) {
37318 arg4 = obj3;
37319 }
37320 {
37321 PyThreadState* __tstate = wxPyBeginAllowThreads();
37322 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37323
37324 wxPyEndAllowThreads(__tstate);
37325 if (PyErr_Occurred()) SWIG_fail;
37326 }
37327 {
37328 resultobj = SWIG_From_int((int)(result));
37329 }
37330 {
37331 if (temp2)
37332 delete arg2;
37333 }
37334 return resultobj;
37335 fail:
37336 {
37337 if (temp2)
37338 delete arg2;
37339 }
37340 return NULL;
37341 }
37342
37343
37344 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37345 PyObject *resultobj;
37346 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37347 PyObject * obj0 = 0 ;
37348 char *kwnames[] = {
37349 (char *) "self", NULL
37350 };
37351
37352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37354 if (SWIG_arg_fail(1)) SWIG_fail;
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 (arg1)->Clear();
37358
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 Py_INCREF(Py_None); resultobj = Py_None;
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj;
37371 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37372 int arg2 ;
37373 PyObject * obj0 = 0 ;
37374 PyObject * obj1 = 0 ;
37375 char *kwnames[] = {
37376 (char *) "self",(char *) "n", NULL
37377 };
37378
37379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37381 if (SWIG_arg_fail(1)) SWIG_fail;
37382 {
37383 arg2 = (int)(SWIG_As_int(obj1));
37384 if (SWIG_arg_fail(2)) SWIG_fail;
37385 }
37386 {
37387 PyThreadState* __tstate = wxPyBeginAllowThreads();
37388 (arg1)->Delete(arg2);
37389
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 Py_INCREF(Py_None); resultobj = Py_None;
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj;
37402 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37403 int arg2 ;
37404 PyObject *result;
37405 PyObject * obj0 = 0 ;
37406 PyObject * obj1 = 0 ;
37407 char *kwnames[] = {
37408 (char *) "self",(char *) "n", NULL
37409 };
37410
37411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37413 if (SWIG_arg_fail(1)) SWIG_fail;
37414 {
37415 arg2 = (int)(SWIG_As_int(obj1));
37416 if (SWIG_arg_fail(2)) SWIG_fail;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37421
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = result;
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37433 PyObject *resultobj;
37434 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37435 int arg2 ;
37436 PyObject *arg3 = (PyObject *) 0 ;
37437 PyObject * obj0 = 0 ;
37438 PyObject * obj1 = 0 ;
37439 PyObject * obj2 = 0 ;
37440 char *kwnames[] = {
37441 (char *) "self",(char *) "n",(char *) "clientData", NULL
37442 };
37443
37444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37446 if (SWIG_arg_fail(1)) SWIG_fail;
37447 {
37448 arg2 = (int)(SWIG_As_int(obj1));
37449 if (SWIG_arg_fail(2)) SWIG_fail;
37450 }
37451 arg3 = obj2;
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 wxItemContainer_SetClientData(arg1,arg2,arg3);
37455
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 Py_INCREF(Py_None); resultobj = Py_None;
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37467 PyObject *resultobj;
37468 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37469 int result;
37470 PyObject * obj0 = 0 ;
37471 char *kwnames[] = {
37472 (char *) "self", NULL
37473 };
37474
37475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37477 if (SWIG_arg_fail(1)) SWIG_fail;
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 result = (int)((wxItemContainer const *)arg1)->GetCount();
37481
37482 wxPyEndAllowThreads(__tstate);
37483 if (PyErr_Occurred()) SWIG_fail;
37484 }
37485 {
37486 resultobj = SWIG_From_int((int)(result));
37487 }
37488 return resultobj;
37489 fail:
37490 return NULL;
37491 }
37492
37493
37494 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37495 PyObject *resultobj;
37496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37497 bool result;
37498 PyObject * obj0 = 0 ;
37499 char *kwnames[] = {
37500 (char *) "self", NULL
37501 };
37502
37503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37505 if (SWIG_arg_fail(1)) SWIG_fail;
37506 {
37507 PyThreadState* __tstate = wxPyBeginAllowThreads();
37508 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37509
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 {
37514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37515 }
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37523 PyObject *resultobj;
37524 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37525 int arg2 ;
37526 wxString result;
37527 PyObject * obj0 = 0 ;
37528 PyObject * obj1 = 0 ;
37529 char *kwnames[] = {
37530 (char *) "self",(char *) "n", NULL
37531 };
37532
37533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37535 if (SWIG_arg_fail(1)) SWIG_fail;
37536 {
37537 arg2 = (int)(SWIG_As_int(obj1));
37538 if (SWIG_arg_fail(2)) SWIG_fail;
37539 }
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37543
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 #if wxUSE_UNICODE
37549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37550 #else
37551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37552 #endif
37553 }
37554 return resultobj;
37555 fail:
37556 return NULL;
37557 }
37558
37559
37560 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37561 PyObject *resultobj;
37562 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37563 wxArrayString result;
37564 PyObject * obj0 = 0 ;
37565 char *kwnames[] = {
37566 (char *) "self", NULL
37567 };
37568
37569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37571 if (SWIG_arg_fail(1)) SWIG_fail;
37572 {
37573 PyThreadState* __tstate = wxPyBeginAllowThreads();
37574 result = ((wxItemContainer const *)arg1)->GetStrings();
37575
37576 wxPyEndAllowThreads(__tstate);
37577 if (PyErr_Occurred()) SWIG_fail;
37578 }
37579 {
37580 resultobj = wxArrayString2PyList_helper(result);
37581 }
37582 return resultobj;
37583 fail:
37584 return NULL;
37585 }
37586
37587
37588 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37589 PyObject *resultobj;
37590 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37591 int arg2 ;
37592 wxString *arg3 = 0 ;
37593 bool temp3 = false ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 PyObject * obj2 = 0 ;
37597 char *kwnames[] = {
37598 (char *) "self",(char *) "n",(char *) "s", NULL
37599 };
37600
37601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37603 if (SWIG_arg_fail(1)) SWIG_fail;
37604 {
37605 arg2 = (int)(SWIG_As_int(obj1));
37606 if (SWIG_arg_fail(2)) SWIG_fail;
37607 }
37608 {
37609 arg3 = wxString_in_helper(obj2);
37610 if (arg3 == NULL) SWIG_fail;
37611 temp3 = true;
37612 }
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 (arg1)->SetString(arg2,(wxString const &)*arg3);
37616
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 Py_INCREF(Py_None); resultobj = Py_None;
37621 {
37622 if (temp3)
37623 delete arg3;
37624 }
37625 return resultobj;
37626 fail:
37627 {
37628 if (temp3)
37629 delete arg3;
37630 }
37631 return NULL;
37632 }
37633
37634
37635 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37636 PyObject *resultobj;
37637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37638 wxString *arg2 = 0 ;
37639 int result;
37640 bool temp2 = false ;
37641 PyObject * obj0 = 0 ;
37642 PyObject * obj1 = 0 ;
37643 char *kwnames[] = {
37644 (char *) "self",(char *) "s", NULL
37645 };
37646
37647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37649 if (SWIG_arg_fail(1)) SWIG_fail;
37650 {
37651 arg2 = wxString_in_helper(obj1);
37652 if (arg2 == NULL) SWIG_fail;
37653 temp2 = true;
37654 }
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37658
37659 wxPyEndAllowThreads(__tstate);
37660 if (PyErr_Occurred()) SWIG_fail;
37661 }
37662 {
37663 resultobj = SWIG_From_int((int)(result));
37664 }
37665 {
37666 if (temp2)
37667 delete arg2;
37668 }
37669 return resultobj;
37670 fail:
37671 {
37672 if (temp2)
37673 delete arg2;
37674 }
37675 return NULL;
37676 }
37677
37678
37679 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37680 PyObject *resultobj;
37681 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37682 int arg2 ;
37683 PyObject * obj0 = 0 ;
37684 PyObject * obj1 = 0 ;
37685 char *kwnames[] = {
37686 (char *) "self",(char *) "n", NULL
37687 };
37688
37689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37691 if (SWIG_arg_fail(1)) SWIG_fail;
37692 {
37693 arg2 = (int)(SWIG_As_int(obj1));
37694 if (SWIG_arg_fail(2)) SWIG_fail;
37695 }
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 (arg1)->SetSelection(arg2);
37699
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 Py_INCREF(Py_None); resultobj = Py_None;
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj;
37712 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37713 int result;
37714 PyObject * obj0 = 0 ;
37715 char *kwnames[] = {
37716 (char *) "self", NULL
37717 };
37718
37719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37721 if (SWIG_arg_fail(1)) SWIG_fail;
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37725
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 {
37730 resultobj = SWIG_From_int((int)(result));
37731 }
37732 return resultobj;
37733 fail:
37734 return NULL;
37735 }
37736
37737
37738 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37739 PyObject *resultobj;
37740 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37741 wxString *arg2 = 0 ;
37742 bool result;
37743 bool temp2 = false ;
37744 PyObject * obj0 = 0 ;
37745 PyObject * obj1 = 0 ;
37746 char *kwnames[] = {
37747 (char *) "self",(char *) "s", NULL
37748 };
37749
37750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37752 if (SWIG_arg_fail(1)) SWIG_fail;
37753 {
37754 arg2 = wxString_in_helper(obj1);
37755 if (arg2 == NULL) SWIG_fail;
37756 temp2 = true;
37757 }
37758 {
37759 PyThreadState* __tstate = wxPyBeginAllowThreads();
37760 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37761
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 {
37766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37767 }
37768 {
37769 if (temp2)
37770 delete arg2;
37771 }
37772 return resultobj;
37773 fail:
37774 {
37775 if (temp2)
37776 delete arg2;
37777 }
37778 return NULL;
37779 }
37780
37781
37782 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37783 PyObject *resultobj;
37784 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37785 wxString result;
37786 PyObject * obj0 = 0 ;
37787 char *kwnames[] = {
37788 (char *) "self", NULL
37789 };
37790
37791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37793 if (SWIG_arg_fail(1)) SWIG_fail;
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37797
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 {
37802 #if wxUSE_UNICODE
37803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37804 #else
37805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37806 #endif
37807 }
37808 return resultobj;
37809 fail:
37810 return NULL;
37811 }
37812
37813
37814 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37815 PyObject *resultobj;
37816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37817 int arg2 ;
37818 PyObject * obj0 = 0 ;
37819 PyObject * obj1 = 0 ;
37820 char *kwnames[] = {
37821 (char *) "self",(char *) "n", NULL
37822 };
37823
37824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37826 if (SWIG_arg_fail(1)) SWIG_fail;
37827 {
37828 arg2 = (int)(SWIG_As_int(obj1));
37829 if (SWIG_arg_fail(2)) SWIG_fail;
37830 }
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 (arg1)->Select(arg2);
37834
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 Py_INCREF(Py_None); resultobj = Py_None;
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37846 PyObject *obj;
37847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37848 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37849 Py_INCREF(obj);
37850 return Py_BuildValue((char *)"");
37851 }
37852 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37853 PyObject *obj;
37854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37855 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37856 Py_INCREF(obj);
37857 return Py_BuildValue((char *)"");
37858 }
37859 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37860 PyObject *resultobj;
37861 wxSizerItem *result;
37862 char *kwnames[] = {
37863 NULL
37864 };
37865
37866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 result = (wxSizerItem *)new wxSizerItem();
37870
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37875 return resultobj;
37876 fail:
37877 return NULL;
37878 }
37879
37880
37881 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37882 PyObject *resultobj;
37883 wxWindow *arg1 = (wxWindow *) 0 ;
37884 int arg2 ;
37885 int arg3 ;
37886 int arg4 ;
37887 PyObject *arg5 = (PyObject *) NULL ;
37888 wxSizerItem *result;
37889 PyObject * obj0 = 0 ;
37890 PyObject * obj1 = 0 ;
37891 PyObject * obj2 = 0 ;
37892 PyObject * obj3 = 0 ;
37893 PyObject * obj4 = 0 ;
37894 char *kwnames[] = {
37895 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37896 };
37897
37898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37900 if (SWIG_arg_fail(1)) SWIG_fail;
37901 {
37902 arg2 = (int)(SWIG_As_int(obj1));
37903 if (SWIG_arg_fail(2)) SWIG_fail;
37904 }
37905 {
37906 arg3 = (int)(SWIG_As_int(obj2));
37907 if (SWIG_arg_fail(3)) SWIG_fail;
37908 }
37909 {
37910 arg4 = (int)(SWIG_As_int(obj3));
37911 if (SWIG_arg_fail(4)) SWIG_fail;
37912 }
37913 if (obj4) {
37914 arg5 = obj4;
37915 }
37916 {
37917 PyThreadState* __tstate = wxPyBeginAllowThreads();
37918 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37919
37920 wxPyEndAllowThreads(__tstate);
37921 if (PyErr_Occurred()) SWIG_fail;
37922 }
37923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37924 return resultobj;
37925 fail:
37926 return NULL;
37927 }
37928
37929
37930 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37931 PyObject *resultobj;
37932 int arg1 ;
37933 int arg2 ;
37934 int arg3 ;
37935 int arg4 ;
37936 int arg5 ;
37937 PyObject *arg6 = (PyObject *) NULL ;
37938 wxSizerItem *result;
37939 PyObject * obj0 = 0 ;
37940 PyObject * obj1 = 0 ;
37941 PyObject * obj2 = 0 ;
37942 PyObject * obj3 = 0 ;
37943 PyObject * obj4 = 0 ;
37944 PyObject * obj5 = 0 ;
37945 char *kwnames[] = {
37946 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37947 };
37948
37949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37950 {
37951 arg1 = (int)(SWIG_As_int(obj0));
37952 if (SWIG_arg_fail(1)) SWIG_fail;
37953 }
37954 {
37955 arg2 = (int)(SWIG_As_int(obj1));
37956 if (SWIG_arg_fail(2)) SWIG_fail;
37957 }
37958 {
37959 arg3 = (int)(SWIG_As_int(obj2));
37960 if (SWIG_arg_fail(3)) SWIG_fail;
37961 }
37962 {
37963 arg4 = (int)(SWIG_As_int(obj3));
37964 if (SWIG_arg_fail(4)) SWIG_fail;
37965 }
37966 {
37967 arg5 = (int)(SWIG_As_int(obj4));
37968 if (SWIG_arg_fail(5)) SWIG_fail;
37969 }
37970 if (obj5) {
37971 arg6 = obj5;
37972 }
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37976
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37981 return resultobj;
37982 fail:
37983 return NULL;
37984 }
37985
37986
37987 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37988 PyObject *resultobj;
37989 wxSizer *arg1 = (wxSizer *) 0 ;
37990 int arg2 ;
37991 int arg3 ;
37992 int arg4 ;
37993 PyObject *arg5 = (PyObject *) NULL ;
37994 wxSizerItem *result;
37995 PyObject * obj0 = 0 ;
37996 PyObject * obj1 = 0 ;
37997 PyObject * obj2 = 0 ;
37998 PyObject * obj3 = 0 ;
37999 PyObject * obj4 = 0 ;
38000 char *kwnames[] = {
38001 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38002 };
38003
38004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38006 if (SWIG_arg_fail(1)) SWIG_fail;
38007 {
38008 arg2 = (int)(SWIG_As_int(obj1));
38009 if (SWIG_arg_fail(2)) SWIG_fail;
38010 }
38011 {
38012 arg3 = (int)(SWIG_As_int(obj2));
38013 if (SWIG_arg_fail(3)) SWIG_fail;
38014 }
38015 {
38016 arg4 = (int)(SWIG_As_int(obj3));
38017 if (SWIG_arg_fail(4)) SWIG_fail;
38018 }
38019 if (obj4) {
38020 arg5 = obj4;
38021 }
38022 {
38023 PyThreadState* __tstate = wxPyBeginAllowThreads();
38024 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38025
38026 wxPyEndAllowThreads(__tstate);
38027 if (PyErr_Occurred()) SWIG_fail;
38028 }
38029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38030 return resultobj;
38031 fail:
38032 return NULL;
38033 }
38034
38035
38036 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38037 PyObject *resultobj;
38038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38039 PyObject * obj0 = 0 ;
38040 char *kwnames[] = {
38041 (char *) "self", NULL
38042 };
38043
38044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38046 if (SWIG_arg_fail(1)) SWIG_fail;
38047 {
38048 PyThreadState* __tstate = wxPyBeginAllowThreads();
38049 (arg1)->DeleteWindows();
38050
38051 wxPyEndAllowThreads(__tstate);
38052 if (PyErr_Occurred()) SWIG_fail;
38053 }
38054 Py_INCREF(Py_None); resultobj = Py_None;
38055 return resultobj;
38056 fail:
38057 return NULL;
38058 }
38059
38060
38061 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38062 PyObject *resultobj;
38063 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38064 PyObject * obj0 = 0 ;
38065 char *kwnames[] = {
38066 (char *) "self", NULL
38067 };
38068
38069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38071 if (SWIG_arg_fail(1)) SWIG_fail;
38072 {
38073 PyThreadState* __tstate = wxPyBeginAllowThreads();
38074 (arg1)->DetachSizer();
38075
38076 wxPyEndAllowThreads(__tstate);
38077 if (PyErr_Occurred()) SWIG_fail;
38078 }
38079 Py_INCREF(Py_None); resultobj = Py_None;
38080 return resultobj;
38081 fail:
38082 return NULL;
38083 }
38084
38085
38086 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38087 PyObject *resultobj;
38088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38089 wxSize result;
38090 PyObject * obj0 = 0 ;
38091 char *kwnames[] = {
38092 (char *) "self", NULL
38093 };
38094
38095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38097 if (SWIG_arg_fail(1)) SWIG_fail;
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = (arg1)->GetSize();
38101
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 wxSize * resultptr;
38107 resultptr = new wxSize((wxSize &)(result));
38108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38109 }
38110 return resultobj;
38111 fail:
38112 return NULL;
38113 }
38114
38115
38116 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj;
38118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38119 wxSize result;
38120 PyObject * obj0 = 0 ;
38121 char *kwnames[] = {
38122 (char *) "self", NULL
38123 };
38124
38125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38127 if (SWIG_arg_fail(1)) SWIG_fail;
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = (arg1)->CalcMin();
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 wxSize * resultptr;
38137 resultptr = new wxSize((wxSize &)(result));
38138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj;
38148 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38149 wxPoint arg2 ;
38150 wxSize arg3 ;
38151 PyObject * obj0 = 0 ;
38152 PyObject * obj1 = 0 ;
38153 PyObject * obj2 = 0 ;
38154 char *kwnames[] = {
38155 (char *) "self",(char *) "pos",(char *) "size", NULL
38156 };
38157
38158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38160 if (SWIG_arg_fail(1)) SWIG_fail;
38161 {
38162 wxPoint * argp;
38163 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38164 if (SWIG_arg_fail(2)) SWIG_fail;
38165 if (argp == NULL) {
38166 SWIG_null_ref("wxPoint");
38167 }
38168 if (SWIG_arg_fail(2)) SWIG_fail;
38169 arg2 = *argp;
38170 }
38171 {
38172 wxSize * argp;
38173 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38174 if (SWIG_arg_fail(3)) SWIG_fail;
38175 if (argp == NULL) {
38176 SWIG_null_ref("wxSize");
38177 }
38178 if (SWIG_arg_fail(3)) SWIG_fail;
38179 arg3 = *argp;
38180 }
38181 {
38182 PyThreadState* __tstate = wxPyBeginAllowThreads();
38183 (arg1)->SetDimension(arg2,arg3);
38184
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 Py_INCREF(Py_None); resultobj = Py_None;
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38196 PyObject *resultobj;
38197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38198 wxSize result;
38199 PyObject * obj0 = 0 ;
38200 char *kwnames[] = {
38201 (char *) "self", NULL
38202 };
38203
38204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38206 if (SWIG_arg_fail(1)) SWIG_fail;
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 result = (arg1)->GetMinSize();
38210
38211 wxPyEndAllowThreads(__tstate);
38212 if (PyErr_Occurred()) SWIG_fail;
38213 }
38214 {
38215 wxSize * resultptr;
38216 resultptr = new wxSize((wxSize &)(result));
38217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38218 }
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38226 PyObject *resultobj;
38227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38228 wxSize result;
38229 PyObject * obj0 = 0 ;
38230 char *kwnames[] = {
38231 (char *) "self", NULL
38232 };
38233
38234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38236 if (SWIG_arg_fail(1)) SWIG_fail;
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38240
38241 wxPyEndAllowThreads(__tstate);
38242 if (PyErr_Occurred()) SWIG_fail;
38243 }
38244 {
38245 wxSize * resultptr;
38246 resultptr = new wxSize((wxSize &)(result));
38247 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38248 }
38249 return resultobj;
38250 fail:
38251 return NULL;
38252 }
38253
38254
38255 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38256 PyObject *resultobj;
38257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38258 int arg2 ;
38259 int arg3 ;
38260 PyObject * obj0 = 0 ;
38261 PyObject * obj1 = 0 ;
38262 PyObject * obj2 = 0 ;
38263 char *kwnames[] = {
38264 (char *) "self",(char *) "x",(char *) "y", NULL
38265 };
38266
38267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38269 if (SWIG_arg_fail(1)) SWIG_fail;
38270 {
38271 arg2 = (int)(SWIG_As_int(obj1));
38272 if (SWIG_arg_fail(2)) SWIG_fail;
38273 }
38274 {
38275 arg3 = (int)(SWIG_As_int(obj2));
38276 if (SWIG_arg_fail(3)) SWIG_fail;
38277 }
38278 {
38279 PyThreadState* __tstate = wxPyBeginAllowThreads();
38280 (arg1)->SetInitSize(arg2,arg3);
38281
38282 wxPyEndAllowThreads(__tstate);
38283 if (PyErr_Occurred()) SWIG_fail;
38284 }
38285 Py_INCREF(Py_None); resultobj = Py_None;
38286 return resultobj;
38287 fail:
38288 return NULL;
38289 }
38290
38291
38292 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj;
38294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38295 int arg2 ;
38296 int arg3 ;
38297 PyObject * obj0 = 0 ;
38298 PyObject * obj1 = 0 ;
38299 PyObject * obj2 = 0 ;
38300 char *kwnames[] = {
38301 (char *) "self",(char *) "width",(char *) "height", NULL
38302 };
38303
38304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38306 if (SWIG_arg_fail(1)) SWIG_fail;
38307 {
38308 arg2 = (int)(SWIG_As_int(obj1));
38309 if (SWIG_arg_fail(2)) SWIG_fail;
38310 }
38311 {
38312 arg3 = (int)(SWIG_As_int(obj2));
38313 if (SWIG_arg_fail(3)) SWIG_fail;
38314 }
38315 {
38316 PyThreadState* __tstate = wxPyBeginAllowThreads();
38317 (arg1)->SetRatio(arg2,arg3);
38318
38319 wxPyEndAllowThreads(__tstate);
38320 if (PyErr_Occurred()) SWIG_fail;
38321 }
38322 Py_INCREF(Py_None); resultobj = Py_None;
38323 return resultobj;
38324 fail:
38325 return NULL;
38326 }
38327
38328
38329 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj;
38331 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38332 wxSize arg2 ;
38333 PyObject * obj0 = 0 ;
38334 PyObject * obj1 = 0 ;
38335 char *kwnames[] = {
38336 (char *) "self",(char *) "size", NULL
38337 };
38338
38339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38341 if (SWIG_arg_fail(1)) SWIG_fail;
38342 {
38343 wxSize * argp;
38344 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38345 if (SWIG_arg_fail(2)) SWIG_fail;
38346 if (argp == NULL) {
38347 SWIG_null_ref("wxSize");
38348 }
38349 if (SWIG_arg_fail(2)) SWIG_fail;
38350 arg2 = *argp;
38351 }
38352 {
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 (arg1)->SetRatio(arg2);
38355
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 Py_INCREF(Py_None); resultobj = Py_None;
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38367 PyObject *resultobj;
38368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38369 float arg2 ;
38370 PyObject * obj0 = 0 ;
38371 PyObject * obj1 = 0 ;
38372 char *kwnames[] = {
38373 (char *) "self",(char *) "ratio", NULL
38374 };
38375
38376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38378 if (SWIG_arg_fail(1)) SWIG_fail;
38379 {
38380 arg2 = (float)(SWIG_As_float(obj1));
38381 if (SWIG_arg_fail(2)) SWIG_fail;
38382 }
38383 {
38384 PyThreadState* __tstate = wxPyBeginAllowThreads();
38385 (arg1)->SetRatio(arg2);
38386
38387 wxPyEndAllowThreads(__tstate);
38388 if (PyErr_Occurred()) SWIG_fail;
38389 }
38390 Py_INCREF(Py_None); resultobj = Py_None;
38391 return resultobj;
38392 fail:
38393 return NULL;
38394 }
38395
38396
38397 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38398 PyObject *resultobj;
38399 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38400 float result;
38401 PyObject * obj0 = 0 ;
38402 char *kwnames[] = {
38403 (char *) "self", NULL
38404 };
38405
38406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38408 if (SWIG_arg_fail(1)) SWIG_fail;
38409 {
38410 PyThreadState* __tstate = wxPyBeginAllowThreads();
38411 result = (float)(arg1)->GetRatio();
38412
38413 wxPyEndAllowThreads(__tstate);
38414 if (PyErr_Occurred()) SWIG_fail;
38415 }
38416 {
38417 resultobj = SWIG_From_float((float)(result));
38418 }
38419 return resultobj;
38420 fail:
38421 return NULL;
38422 }
38423
38424
38425 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38426 PyObject *resultobj;
38427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38428 wxRect result;
38429 PyObject * obj0 = 0 ;
38430 char *kwnames[] = {
38431 (char *) "self", NULL
38432 };
38433
38434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38436 if (SWIG_arg_fail(1)) SWIG_fail;
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (arg1)->GetRect();
38440
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 {
38445 wxRect * resultptr;
38446 resultptr = new wxRect((wxRect &)(result));
38447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38448 }
38449 return resultobj;
38450 fail:
38451 return NULL;
38452 }
38453
38454
38455 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38456 PyObject *resultobj;
38457 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38458 bool result;
38459 PyObject * obj0 = 0 ;
38460 char *kwnames[] = {
38461 (char *) "self", NULL
38462 };
38463
38464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38466 if (SWIG_arg_fail(1)) SWIG_fail;
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (bool)(arg1)->IsWindow();
38470
38471 wxPyEndAllowThreads(__tstate);
38472 if (PyErr_Occurred()) SWIG_fail;
38473 }
38474 {
38475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38476 }
38477 return resultobj;
38478 fail:
38479 return NULL;
38480 }
38481
38482
38483 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38484 PyObject *resultobj;
38485 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38486 bool result;
38487 PyObject * obj0 = 0 ;
38488 char *kwnames[] = {
38489 (char *) "self", NULL
38490 };
38491
38492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38494 if (SWIG_arg_fail(1)) SWIG_fail;
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 result = (bool)(arg1)->IsSizer();
38498
38499 wxPyEndAllowThreads(__tstate);
38500 if (PyErr_Occurred()) SWIG_fail;
38501 }
38502 {
38503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38504 }
38505 return resultobj;
38506 fail:
38507 return NULL;
38508 }
38509
38510
38511 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38512 PyObject *resultobj;
38513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38514 bool result;
38515 PyObject * obj0 = 0 ;
38516 char *kwnames[] = {
38517 (char *) "self", NULL
38518 };
38519
38520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38522 if (SWIG_arg_fail(1)) SWIG_fail;
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (bool)(arg1)->IsSpacer();
38526
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 {
38531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38532 }
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38540 PyObject *resultobj;
38541 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38542 int arg2 ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 char *kwnames[] = {
38546 (char *) "self",(char *) "proportion", NULL
38547 };
38548
38549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38551 if (SWIG_arg_fail(1)) SWIG_fail;
38552 {
38553 arg2 = (int)(SWIG_As_int(obj1));
38554 if (SWIG_arg_fail(2)) SWIG_fail;
38555 }
38556 {
38557 PyThreadState* __tstate = wxPyBeginAllowThreads();
38558 (arg1)->SetProportion(arg2);
38559
38560 wxPyEndAllowThreads(__tstate);
38561 if (PyErr_Occurred()) SWIG_fail;
38562 }
38563 Py_INCREF(Py_None); resultobj = Py_None;
38564 return resultobj;
38565 fail:
38566 return NULL;
38567 }
38568
38569
38570 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38571 PyObject *resultobj;
38572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38573 int result;
38574 PyObject * obj0 = 0 ;
38575 char *kwnames[] = {
38576 (char *) "self", NULL
38577 };
38578
38579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38581 if (SWIG_arg_fail(1)) SWIG_fail;
38582 {
38583 PyThreadState* __tstate = wxPyBeginAllowThreads();
38584 result = (int)(arg1)->GetProportion();
38585
38586 wxPyEndAllowThreads(__tstate);
38587 if (PyErr_Occurred()) SWIG_fail;
38588 }
38589 {
38590 resultobj = SWIG_From_int((int)(result));
38591 }
38592 return resultobj;
38593 fail:
38594 return NULL;
38595 }
38596
38597
38598 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj;
38600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38601 int arg2 ;
38602 PyObject * obj0 = 0 ;
38603 PyObject * obj1 = 0 ;
38604 char *kwnames[] = {
38605 (char *) "self",(char *) "flag", NULL
38606 };
38607
38608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38610 if (SWIG_arg_fail(1)) SWIG_fail;
38611 {
38612 arg2 = (int)(SWIG_As_int(obj1));
38613 if (SWIG_arg_fail(2)) SWIG_fail;
38614 }
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 (arg1)->SetFlag(arg2);
38618
38619 wxPyEndAllowThreads(__tstate);
38620 if (PyErr_Occurred()) SWIG_fail;
38621 }
38622 Py_INCREF(Py_None); resultobj = Py_None;
38623 return resultobj;
38624 fail:
38625 return NULL;
38626 }
38627
38628
38629 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38630 PyObject *resultobj;
38631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38632 int result;
38633 PyObject * obj0 = 0 ;
38634 char *kwnames[] = {
38635 (char *) "self", NULL
38636 };
38637
38638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38640 if (SWIG_arg_fail(1)) SWIG_fail;
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (int)(arg1)->GetFlag();
38644
38645 wxPyEndAllowThreads(__tstate);
38646 if (PyErr_Occurred()) SWIG_fail;
38647 }
38648 {
38649 resultobj = SWIG_From_int((int)(result));
38650 }
38651 return resultobj;
38652 fail:
38653 return NULL;
38654 }
38655
38656
38657 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38658 PyObject *resultobj;
38659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38660 int arg2 ;
38661 PyObject * obj0 = 0 ;
38662 PyObject * obj1 = 0 ;
38663 char *kwnames[] = {
38664 (char *) "self",(char *) "border", NULL
38665 };
38666
38667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38669 if (SWIG_arg_fail(1)) SWIG_fail;
38670 {
38671 arg2 = (int)(SWIG_As_int(obj1));
38672 if (SWIG_arg_fail(2)) SWIG_fail;
38673 }
38674 {
38675 PyThreadState* __tstate = wxPyBeginAllowThreads();
38676 (arg1)->SetBorder(arg2);
38677
38678 wxPyEndAllowThreads(__tstate);
38679 if (PyErr_Occurred()) SWIG_fail;
38680 }
38681 Py_INCREF(Py_None); resultobj = Py_None;
38682 return resultobj;
38683 fail:
38684 return NULL;
38685 }
38686
38687
38688 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38689 PyObject *resultobj;
38690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38691 int result;
38692 PyObject * obj0 = 0 ;
38693 char *kwnames[] = {
38694 (char *) "self", NULL
38695 };
38696
38697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38699 if (SWIG_arg_fail(1)) SWIG_fail;
38700 {
38701 PyThreadState* __tstate = wxPyBeginAllowThreads();
38702 result = (int)(arg1)->GetBorder();
38703
38704 wxPyEndAllowThreads(__tstate);
38705 if (PyErr_Occurred()) SWIG_fail;
38706 }
38707 {
38708 resultobj = SWIG_From_int((int)(result));
38709 }
38710 return resultobj;
38711 fail:
38712 return NULL;
38713 }
38714
38715
38716 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38717 PyObject *resultobj;
38718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38719 wxWindow *result;
38720 PyObject * obj0 = 0 ;
38721 char *kwnames[] = {
38722 (char *) "self", NULL
38723 };
38724
38725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38727 if (SWIG_arg_fail(1)) SWIG_fail;
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (wxWindow *)(arg1)->GetWindow();
38731
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxPyMake_wxObject(result, 0);
38737 }
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj;
38746 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38747 wxWindow *arg2 = (wxWindow *) 0 ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 char *kwnames[] = {
38751 (char *) "self",(char *) "window", NULL
38752 };
38753
38754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38756 if (SWIG_arg_fail(1)) SWIG_fail;
38757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38758 if (SWIG_arg_fail(2)) SWIG_fail;
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 (arg1)->SetWindow(arg2);
38762
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 Py_INCREF(Py_None); resultobj = Py_None;
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj;
38775 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38776 wxSizer *result;
38777 PyObject * obj0 = 0 ;
38778 char *kwnames[] = {
38779 (char *) "self", NULL
38780 };
38781
38782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38784 if (SWIG_arg_fail(1)) SWIG_fail;
38785 {
38786 PyThreadState* __tstate = wxPyBeginAllowThreads();
38787 result = (wxSizer *)(arg1)->GetSizer();
38788
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 {
38793 resultobj = wxPyMake_wxSizer(result, 0);
38794 }
38795 return resultobj;
38796 fail:
38797 return NULL;
38798 }
38799
38800
38801 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38802 PyObject *resultobj;
38803 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38804 wxSizer *arg2 = (wxSizer *) 0 ;
38805 PyObject * obj0 = 0 ;
38806 PyObject * obj1 = 0 ;
38807 char *kwnames[] = {
38808 (char *) "self",(char *) "sizer", NULL
38809 };
38810
38811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38813 if (SWIG_arg_fail(1)) SWIG_fail;
38814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38815 if (SWIG_arg_fail(2)) SWIG_fail;
38816 {
38817 PyThreadState* __tstate = wxPyBeginAllowThreads();
38818 (arg1)->SetSizer(arg2);
38819
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 Py_INCREF(Py_None); resultobj = Py_None;
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj;
38832 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38833 wxSize *result;
38834 PyObject * obj0 = 0 ;
38835 char *kwnames[] = {
38836 (char *) "self", NULL
38837 };
38838
38839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38841 if (SWIG_arg_fail(1)) SWIG_fail;
38842 {
38843 PyThreadState* __tstate = wxPyBeginAllowThreads();
38844 {
38845 wxSize const &_result_ref = (arg1)->GetSpacer();
38846 result = (wxSize *) &_result_ref;
38847 }
38848
38849 wxPyEndAllowThreads(__tstate);
38850 if (PyErr_Occurred()) SWIG_fail;
38851 }
38852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38853 return resultobj;
38854 fail:
38855 return NULL;
38856 }
38857
38858
38859 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38860 PyObject *resultobj;
38861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38862 wxSize *arg2 = 0 ;
38863 wxSize temp2 ;
38864 PyObject * obj0 = 0 ;
38865 PyObject * obj1 = 0 ;
38866 char *kwnames[] = {
38867 (char *) "self",(char *) "size", NULL
38868 };
38869
38870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38872 if (SWIG_arg_fail(1)) SWIG_fail;
38873 {
38874 arg2 = &temp2;
38875 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38876 }
38877 {
38878 PyThreadState* __tstate = wxPyBeginAllowThreads();
38879 (arg1)->SetSpacer((wxSize const &)*arg2);
38880
38881 wxPyEndAllowThreads(__tstate);
38882 if (PyErr_Occurred()) SWIG_fail;
38883 }
38884 Py_INCREF(Py_None); resultobj = Py_None;
38885 return resultobj;
38886 fail:
38887 return NULL;
38888 }
38889
38890
38891 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38892 PyObject *resultobj;
38893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38894 bool arg2 ;
38895 PyObject * obj0 = 0 ;
38896 PyObject * obj1 = 0 ;
38897 char *kwnames[] = {
38898 (char *) "self",(char *) "show", NULL
38899 };
38900
38901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38903 if (SWIG_arg_fail(1)) SWIG_fail;
38904 {
38905 arg2 = (bool)(SWIG_As_bool(obj1));
38906 if (SWIG_arg_fail(2)) SWIG_fail;
38907 }
38908 {
38909 PyThreadState* __tstate = wxPyBeginAllowThreads();
38910 (arg1)->Show(arg2);
38911
38912 wxPyEndAllowThreads(__tstate);
38913 if (PyErr_Occurred()) SWIG_fail;
38914 }
38915 Py_INCREF(Py_None); resultobj = Py_None;
38916 return resultobj;
38917 fail:
38918 return NULL;
38919 }
38920
38921
38922 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38923 PyObject *resultobj;
38924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38925 bool result;
38926 PyObject * obj0 = 0 ;
38927 char *kwnames[] = {
38928 (char *) "self", NULL
38929 };
38930
38931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38933 if (SWIG_arg_fail(1)) SWIG_fail;
38934 {
38935 PyThreadState* __tstate = wxPyBeginAllowThreads();
38936 result = (bool)(arg1)->IsShown();
38937
38938 wxPyEndAllowThreads(__tstate);
38939 if (PyErr_Occurred()) SWIG_fail;
38940 }
38941 {
38942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38943 }
38944 return resultobj;
38945 fail:
38946 return NULL;
38947 }
38948
38949
38950 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj;
38952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38953 wxPoint result;
38954 PyObject * obj0 = 0 ;
38955 char *kwnames[] = {
38956 (char *) "self", NULL
38957 };
38958
38959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38961 if (SWIG_arg_fail(1)) SWIG_fail;
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (arg1)->GetPosition();
38965
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 wxPoint * resultptr;
38971 resultptr = new wxPoint((wxPoint &)(result));
38972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38973 }
38974 return resultobj;
38975 fail:
38976 return NULL;
38977 }
38978
38979
38980 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38981 PyObject *resultobj;
38982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38983 PyObject *result;
38984 PyObject * obj0 = 0 ;
38985 char *kwnames[] = {
38986 (char *) "self", NULL
38987 };
38988
38989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38991 if (SWIG_arg_fail(1)) SWIG_fail;
38992 {
38993 PyThreadState* __tstate = wxPyBeginAllowThreads();
38994 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38995
38996 wxPyEndAllowThreads(__tstate);
38997 if (PyErr_Occurred()) SWIG_fail;
38998 }
38999 resultobj = result;
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39007 PyObject *obj;
39008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39009 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39010 Py_INCREF(obj);
39011 return Py_BuildValue((char *)"");
39012 }
39013 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39014 PyObject *resultobj;
39015 wxSizer *arg1 = (wxSizer *) 0 ;
39016 PyObject *arg2 = (PyObject *) 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 char *kwnames[] = {
39020 (char *) "self",(char *) "_self", NULL
39021 };
39022
39023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39025 if (SWIG_arg_fail(1)) SWIG_fail;
39026 arg2 = obj1;
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 wxSizer__setOORInfo(arg1,arg2);
39030
39031 wxPyEndAllowThreads(__tstate);
39032 if (PyErr_Occurred()) SWIG_fail;
39033 }
39034 Py_INCREF(Py_None); resultobj = Py_None;
39035 return resultobj;
39036 fail:
39037 return NULL;
39038 }
39039
39040
39041 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39042 PyObject *resultobj;
39043 wxSizer *arg1 = (wxSizer *) 0 ;
39044 PyObject *arg2 = (PyObject *) 0 ;
39045 int arg3 = (int) 0 ;
39046 int arg4 = (int) 0 ;
39047 int arg5 = (int) 0 ;
39048 PyObject *arg6 = (PyObject *) NULL ;
39049 wxSizerItem *result;
39050 PyObject * obj0 = 0 ;
39051 PyObject * obj1 = 0 ;
39052 PyObject * obj2 = 0 ;
39053 PyObject * obj3 = 0 ;
39054 PyObject * obj4 = 0 ;
39055 PyObject * obj5 = 0 ;
39056 char *kwnames[] = {
39057 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39058 };
39059
39060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39062 if (SWIG_arg_fail(1)) SWIG_fail;
39063 arg2 = obj1;
39064 if (obj2) {
39065 {
39066 arg3 = (int)(SWIG_As_int(obj2));
39067 if (SWIG_arg_fail(3)) SWIG_fail;
39068 }
39069 }
39070 if (obj3) {
39071 {
39072 arg4 = (int)(SWIG_As_int(obj3));
39073 if (SWIG_arg_fail(4)) SWIG_fail;
39074 }
39075 }
39076 if (obj4) {
39077 {
39078 arg5 = (int)(SWIG_As_int(obj4));
39079 if (SWIG_arg_fail(5)) SWIG_fail;
39080 }
39081 }
39082 if (obj5) {
39083 arg6 = obj5;
39084 }
39085 {
39086 PyThreadState* __tstate = wxPyBeginAllowThreads();
39087 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39088
39089 wxPyEndAllowThreads(__tstate);
39090 if (PyErr_Occurred()) SWIG_fail;
39091 }
39092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39093 return resultobj;
39094 fail:
39095 return NULL;
39096 }
39097
39098
39099 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39100 PyObject *resultobj;
39101 wxSizer *arg1 = (wxSizer *) 0 ;
39102 int arg2 ;
39103 PyObject *arg3 = (PyObject *) 0 ;
39104 int arg4 = (int) 0 ;
39105 int arg5 = (int) 0 ;
39106 int arg6 = (int) 0 ;
39107 PyObject *arg7 = (PyObject *) NULL ;
39108 wxSizerItem *result;
39109 PyObject * obj0 = 0 ;
39110 PyObject * obj1 = 0 ;
39111 PyObject * obj2 = 0 ;
39112 PyObject * obj3 = 0 ;
39113 PyObject * obj4 = 0 ;
39114 PyObject * obj5 = 0 ;
39115 PyObject * obj6 = 0 ;
39116 char *kwnames[] = {
39117 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39118 };
39119
39120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39122 if (SWIG_arg_fail(1)) SWIG_fail;
39123 {
39124 arg2 = (int)(SWIG_As_int(obj1));
39125 if (SWIG_arg_fail(2)) SWIG_fail;
39126 }
39127 arg3 = obj2;
39128 if (obj3) {
39129 {
39130 arg4 = (int)(SWIG_As_int(obj3));
39131 if (SWIG_arg_fail(4)) SWIG_fail;
39132 }
39133 }
39134 if (obj4) {
39135 {
39136 arg5 = (int)(SWIG_As_int(obj4));
39137 if (SWIG_arg_fail(5)) SWIG_fail;
39138 }
39139 }
39140 if (obj5) {
39141 {
39142 arg6 = (int)(SWIG_As_int(obj5));
39143 if (SWIG_arg_fail(6)) SWIG_fail;
39144 }
39145 }
39146 if (obj6) {
39147 arg7 = obj6;
39148 }
39149 {
39150 PyThreadState* __tstate = wxPyBeginAllowThreads();
39151 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39152
39153 wxPyEndAllowThreads(__tstate);
39154 if (PyErr_Occurred()) SWIG_fail;
39155 }
39156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39157 return resultobj;
39158 fail:
39159 return NULL;
39160 }
39161
39162
39163 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39164 PyObject *resultobj;
39165 wxSizer *arg1 = (wxSizer *) 0 ;
39166 PyObject *arg2 = (PyObject *) 0 ;
39167 int arg3 = (int) 0 ;
39168 int arg4 = (int) 0 ;
39169 int arg5 = (int) 0 ;
39170 PyObject *arg6 = (PyObject *) NULL ;
39171 wxSizerItem *result;
39172 PyObject * obj0 = 0 ;
39173 PyObject * obj1 = 0 ;
39174 PyObject * obj2 = 0 ;
39175 PyObject * obj3 = 0 ;
39176 PyObject * obj4 = 0 ;
39177 PyObject * obj5 = 0 ;
39178 char *kwnames[] = {
39179 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39180 };
39181
39182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39184 if (SWIG_arg_fail(1)) SWIG_fail;
39185 arg2 = obj1;
39186 if (obj2) {
39187 {
39188 arg3 = (int)(SWIG_As_int(obj2));
39189 if (SWIG_arg_fail(3)) SWIG_fail;
39190 }
39191 }
39192 if (obj3) {
39193 {
39194 arg4 = (int)(SWIG_As_int(obj3));
39195 if (SWIG_arg_fail(4)) SWIG_fail;
39196 }
39197 }
39198 if (obj4) {
39199 {
39200 arg5 = (int)(SWIG_As_int(obj4));
39201 if (SWIG_arg_fail(5)) SWIG_fail;
39202 }
39203 }
39204 if (obj5) {
39205 arg6 = obj5;
39206 }
39207 {
39208 PyThreadState* __tstate = wxPyBeginAllowThreads();
39209 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39210
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39215 return resultobj;
39216 fail:
39217 return NULL;
39218 }
39219
39220
39221 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39222 PyObject *resultobj;
39223 wxSizer *arg1 = (wxSizer *) 0 ;
39224 PyObject *arg2 = (PyObject *) 0 ;
39225 bool result;
39226 PyObject * obj0 = 0 ;
39227 PyObject * obj1 = 0 ;
39228 char *kwnames[] = {
39229 (char *) "self",(char *) "item", NULL
39230 };
39231
39232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39234 if (SWIG_arg_fail(1)) SWIG_fail;
39235 arg2 = obj1;
39236 {
39237 PyThreadState* __tstate = wxPyBeginAllowThreads();
39238 result = (bool)wxSizer_Remove(arg1,arg2);
39239
39240 wxPyEndAllowThreads(__tstate);
39241 if (PyErr_Occurred()) SWIG_fail;
39242 }
39243 {
39244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39245 }
39246 return resultobj;
39247 fail:
39248 return NULL;
39249 }
39250
39251
39252 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39253 PyObject *resultobj;
39254 wxSizer *arg1 = (wxSizer *) 0 ;
39255 PyObject *arg2 = (PyObject *) 0 ;
39256 bool result;
39257 PyObject * obj0 = 0 ;
39258 PyObject * obj1 = 0 ;
39259 char *kwnames[] = {
39260 (char *) "self",(char *) "item", NULL
39261 };
39262
39263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39265 if (SWIG_arg_fail(1)) SWIG_fail;
39266 arg2 = obj1;
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 result = (bool)wxSizer_Detach(arg1,arg2);
39270
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 {
39275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39276 }
39277 return resultobj;
39278 fail:
39279 return NULL;
39280 }
39281
39282
39283 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39284 PyObject *resultobj;
39285 wxSizer *arg1 = (wxSizer *) 0 ;
39286 PyObject *arg2 = (PyObject *) 0 ;
39287 wxSizerItem *result;
39288 PyObject * obj0 = 0 ;
39289 PyObject * obj1 = 0 ;
39290 char *kwnames[] = {
39291 (char *) "self",(char *) "item", NULL
39292 };
39293
39294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39296 if (SWIG_arg_fail(1)) SWIG_fail;
39297 arg2 = obj1;
39298 {
39299 PyThreadState* __tstate = wxPyBeginAllowThreads();
39300 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39301
39302 wxPyEndAllowThreads(__tstate);
39303 if (PyErr_Occurred()) SWIG_fail;
39304 }
39305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39306 return resultobj;
39307 fail:
39308 return NULL;
39309 }
39310
39311
39312 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39313 PyObject *resultobj;
39314 wxSizer *arg1 = (wxSizer *) 0 ;
39315 PyObject *arg2 = (PyObject *) 0 ;
39316 wxSize *arg3 = 0 ;
39317 wxSize temp3 ;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 PyObject * obj2 = 0 ;
39321 char *kwnames[] = {
39322 (char *) "self",(char *) "item",(char *) "size", NULL
39323 };
39324
39325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39327 if (SWIG_arg_fail(1)) SWIG_fail;
39328 arg2 = obj1;
39329 {
39330 arg3 = &temp3;
39331 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39332 }
39333 {
39334 PyThreadState* __tstate = wxPyBeginAllowThreads();
39335 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39336
39337 wxPyEndAllowThreads(__tstate);
39338 if (PyErr_Occurred()) SWIG_fail;
39339 }
39340 Py_INCREF(Py_None); resultobj = Py_None;
39341 return resultobj;
39342 fail:
39343 return NULL;
39344 }
39345
39346
39347 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39348 PyObject *resultobj;
39349 wxSizer *arg1 = (wxSizer *) 0 ;
39350 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39351 wxSizerItem *result;
39352 PyObject * obj0 = 0 ;
39353 PyObject * obj1 = 0 ;
39354 char *kwnames[] = {
39355 (char *) "self",(char *) "item", NULL
39356 };
39357
39358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39360 if (SWIG_arg_fail(1)) SWIG_fail;
39361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39362 if (SWIG_arg_fail(2)) SWIG_fail;
39363 {
39364 PyThreadState* __tstate = wxPyBeginAllowThreads();
39365 result = (wxSizerItem *)(arg1)->Add(arg2);
39366
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39371 return resultobj;
39372 fail:
39373 return NULL;
39374 }
39375
39376
39377 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39378 PyObject *resultobj;
39379 wxSizer *arg1 = (wxSizer *) 0 ;
39380 size_t arg2 ;
39381 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39382 wxSizerItem *result;
39383 PyObject * obj0 = 0 ;
39384 PyObject * obj1 = 0 ;
39385 PyObject * obj2 = 0 ;
39386 char *kwnames[] = {
39387 (char *) "self",(char *) "index",(char *) "item", NULL
39388 };
39389
39390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39392 if (SWIG_arg_fail(1)) SWIG_fail;
39393 {
39394 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39395 if (SWIG_arg_fail(2)) SWIG_fail;
39396 }
39397 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39398 if (SWIG_arg_fail(3)) SWIG_fail;
39399 {
39400 PyThreadState* __tstate = wxPyBeginAllowThreads();
39401 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39402
39403 wxPyEndAllowThreads(__tstate);
39404 if (PyErr_Occurred()) SWIG_fail;
39405 }
39406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39407 return resultobj;
39408 fail:
39409 return NULL;
39410 }
39411
39412
39413 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39414 PyObject *resultobj;
39415 wxSizer *arg1 = (wxSizer *) 0 ;
39416 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39417 wxSizerItem *result;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 char *kwnames[] = {
39421 (char *) "self",(char *) "item", NULL
39422 };
39423
39424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39426 if (SWIG_arg_fail(1)) SWIG_fail;
39427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39428 if (SWIG_arg_fail(2)) SWIG_fail;
39429 {
39430 PyThreadState* __tstate = wxPyBeginAllowThreads();
39431 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39432
39433 wxPyEndAllowThreads(__tstate);
39434 if (PyErr_Occurred()) SWIG_fail;
39435 }
39436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39437 return resultobj;
39438 fail:
39439 return NULL;
39440 }
39441
39442
39443 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39444 PyObject *resultobj;
39445 wxSizer *arg1 = (wxSizer *) 0 ;
39446 int arg2 ;
39447 int arg3 ;
39448 int arg4 ;
39449 int arg5 ;
39450 PyObject * obj0 = 0 ;
39451 PyObject * obj1 = 0 ;
39452 PyObject * obj2 = 0 ;
39453 PyObject * obj3 = 0 ;
39454 PyObject * obj4 = 0 ;
39455 char *kwnames[] = {
39456 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39457 };
39458
39459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39461 if (SWIG_arg_fail(1)) SWIG_fail;
39462 {
39463 arg2 = (int)(SWIG_As_int(obj1));
39464 if (SWIG_arg_fail(2)) SWIG_fail;
39465 }
39466 {
39467 arg3 = (int)(SWIG_As_int(obj2));
39468 if (SWIG_arg_fail(3)) SWIG_fail;
39469 }
39470 {
39471 arg4 = (int)(SWIG_As_int(obj3));
39472 if (SWIG_arg_fail(4)) SWIG_fail;
39473 }
39474 {
39475 arg5 = (int)(SWIG_As_int(obj4));
39476 if (SWIG_arg_fail(5)) SWIG_fail;
39477 }
39478 {
39479 PyThreadState* __tstate = wxPyBeginAllowThreads();
39480 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39481
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 Py_INCREF(Py_None); resultobj = Py_None;
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39493 PyObject *resultobj;
39494 wxSizer *arg1 = (wxSizer *) 0 ;
39495 wxSize *arg2 = 0 ;
39496 wxSize temp2 ;
39497 PyObject * obj0 = 0 ;
39498 PyObject * obj1 = 0 ;
39499 char *kwnames[] = {
39500 (char *) "self",(char *) "size", NULL
39501 };
39502
39503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39505 if (SWIG_arg_fail(1)) SWIG_fail;
39506 {
39507 arg2 = &temp2;
39508 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39509 }
39510 {
39511 PyThreadState* __tstate = wxPyBeginAllowThreads();
39512 (arg1)->SetMinSize((wxSize const &)*arg2);
39513
39514 wxPyEndAllowThreads(__tstate);
39515 if (PyErr_Occurred()) SWIG_fail;
39516 }
39517 Py_INCREF(Py_None); resultobj = Py_None;
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj;
39526 wxSizer *arg1 = (wxSizer *) 0 ;
39527 wxSize result;
39528 PyObject * obj0 = 0 ;
39529 char *kwnames[] = {
39530 (char *) "self", NULL
39531 };
39532
39533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39535 if (SWIG_arg_fail(1)) SWIG_fail;
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (arg1)->GetSize();
39539
39540 wxPyEndAllowThreads(__tstate);
39541 if (PyErr_Occurred()) SWIG_fail;
39542 }
39543 {
39544 wxSize * resultptr;
39545 resultptr = new wxSize((wxSize &)(result));
39546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39547 }
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj;
39556 wxSizer *arg1 = (wxSizer *) 0 ;
39557 wxPoint result;
39558 PyObject * obj0 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39565 if (SWIG_arg_fail(1)) SWIG_fail;
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (arg1)->GetPosition();
39569
39570 wxPyEndAllowThreads(__tstate);
39571 if (PyErr_Occurred()) SWIG_fail;
39572 }
39573 {
39574 wxPoint * resultptr;
39575 resultptr = new wxPoint((wxPoint &)(result));
39576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39577 }
39578 return resultobj;
39579 fail:
39580 return NULL;
39581 }
39582
39583
39584 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39585 PyObject *resultobj;
39586 wxSizer *arg1 = (wxSizer *) 0 ;
39587 wxSize result;
39588 PyObject * obj0 = 0 ;
39589 char *kwnames[] = {
39590 (char *) "self", NULL
39591 };
39592
39593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39595 if (SWIG_arg_fail(1)) SWIG_fail;
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (arg1)->GetMinSize();
39599
39600 wxPyEndAllowThreads(__tstate);
39601 if (PyErr_Occurred()) SWIG_fail;
39602 }
39603 {
39604 wxSize * resultptr;
39605 resultptr = new wxSize((wxSize &)(result));
39606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39607 }
39608 return resultobj;
39609 fail:
39610 return NULL;
39611 }
39612
39613
39614 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39615 PyObject *resultobj;
39616 wxSizer *arg1 = (wxSizer *) 0 ;
39617 PyObject * obj0 = 0 ;
39618 char *kwnames[] = {
39619 (char *) "self", NULL
39620 };
39621
39622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39624 if (SWIG_arg_fail(1)) SWIG_fail;
39625 {
39626 PyThreadState* __tstate = wxPyBeginAllowThreads();
39627 (arg1)->RecalcSizes();
39628
39629 wxPyEndAllowThreads(__tstate);
39630 if (PyErr_Occurred()) SWIG_fail;
39631 }
39632 Py_INCREF(Py_None); resultobj = Py_None;
39633 return resultobj;
39634 fail:
39635 return NULL;
39636 }
39637
39638
39639 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39640 PyObject *resultobj;
39641 wxSizer *arg1 = (wxSizer *) 0 ;
39642 wxSize result;
39643 PyObject * obj0 = 0 ;
39644 char *kwnames[] = {
39645 (char *) "self", NULL
39646 };
39647
39648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39650 if (SWIG_arg_fail(1)) SWIG_fail;
39651 {
39652 PyThreadState* __tstate = wxPyBeginAllowThreads();
39653 result = (arg1)->CalcMin();
39654
39655 wxPyEndAllowThreads(__tstate);
39656 if (PyErr_Occurred()) SWIG_fail;
39657 }
39658 {
39659 wxSize * resultptr;
39660 resultptr = new wxSize((wxSize &)(result));
39661 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39662 }
39663 return resultobj;
39664 fail:
39665 return NULL;
39666 }
39667
39668
39669 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39670 PyObject *resultobj;
39671 wxSizer *arg1 = (wxSizer *) 0 ;
39672 PyObject * obj0 = 0 ;
39673 char *kwnames[] = {
39674 (char *) "self", NULL
39675 };
39676
39677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39679 if (SWIG_arg_fail(1)) SWIG_fail;
39680 {
39681 PyThreadState* __tstate = wxPyBeginAllowThreads();
39682 (arg1)->Layout();
39683
39684 wxPyEndAllowThreads(__tstate);
39685 if (PyErr_Occurred()) SWIG_fail;
39686 }
39687 Py_INCREF(Py_None); resultobj = Py_None;
39688 return resultobj;
39689 fail:
39690 return NULL;
39691 }
39692
39693
39694 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39695 PyObject *resultobj;
39696 wxSizer *arg1 = (wxSizer *) 0 ;
39697 wxWindow *arg2 = (wxWindow *) 0 ;
39698 wxSize result;
39699 PyObject * obj0 = 0 ;
39700 PyObject * obj1 = 0 ;
39701 char *kwnames[] = {
39702 (char *) "self",(char *) "window", NULL
39703 };
39704
39705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39707 if (SWIG_arg_fail(1)) SWIG_fail;
39708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39709 if (SWIG_arg_fail(2)) SWIG_fail;
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 result = (arg1)->Fit(arg2);
39713
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 {
39718 wxSize * resultptr;
39719 resultptr = new wxSize((wxSize &)(result));
39720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39721 }
39722 return resultobj;
39723 fail:
39724 return NULL;
39725 }
39726
39727
39728 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39729 PyObject *resultobj;
39730 wxSizer *arg1 = (wxSizer *) 0 ;
39731 wxWindow *arg2 = (wxWindow *) 0 ;
39732 PyObject * obj0 = 0 ;
39733 PyObject * obj1 = 0 ;
39734 char *kwnames[] = {
39735 (char *) "self",(char *) "window", NULL
39736 };
39737
39738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39740 if (SWIG_arg_fail(1)) SWIG_fail;
39741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39742 if (SWIG_arg_fail(2)) SWIG_fail;
39743 {
39744 PyThreadState* __tstate = wxPyBeginAllowThreads();
39745 (arg1)->FitInside(arg2);
39746
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 Py_INCREF(Py_None); resultobj = Py_None;
39751 return resultobj;
39752 fail:
39753 return NULL;
39754 }
39755
39756
39757 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39758 PyObject *resultobj;
39759 wxSizer *arg1 = (wxSizer *) 0 ;
39760 wxWindow *arg2 = (wxWindow *) 0 ;
39761 PyObject * obj0 = 0 ;
39762 PyObject * obj1 = 0 ;
39763 char *kwnames[] = {
39764 (char *) "self",(char *) "window", NULL
39765 };
39766
39767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39769 if (SWIG_arg_fail(1)) SWIG_fail;
39770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39771 if (SWIG_arg_fail(2)) SWIG_fail;
39772 {
39773 PyThreadState* __tstate = wxPyBeginAllowThreads();
39774 (arg1)->SetSizeHints(arg2);
39775
39776 wxPyEndAllowThreads(__tstate);
39777 if (PyErr_Occurred()) SWIG_fail;
39778 }
39779 Py_INCREF(Py_None); resultobj = Py_None;
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj;
39788 wxSizer *arg1 = (wxSizer *) 0 ;
39789 wxWindow *arg2 = (wxWindow *) 0 ;
39790 PyObject * obj0 = 0 ;
39791 PyObject * obj1 = 0 ;
39792 char *kwnames[] = {
39793 (char *) "self",(char *) "window", NULL
39794 };
39795
39796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39798 if (SWIG_arg_fail(1)) SWIG_fail;
39799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39800 if (SWIG_arg_fail(2)) SWIG_fail;
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 (arg1)->SetVirtualSizeHints(arg2);
39804
39805 wxPyEndAllowThreads(__tstate);
39806 if (PyErr_Occurred()) SWIG_fail;
39807 }
39808 Py_INCREF(Py_None); resultobj = Py_None;
39809 return resultobj;
39810 fail:
39811 return NULL;
39812 }
39813
39814
39815 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj;
39817 wxSizer *arg1 = (wxSizer *) 0 ;
39818 bool arg2 = (bool) false ;
39819 PyObject * obj0 = 0 ;
39820 PyObject * obj1 = 0 ;
39821 char *kwnames[] = {
39822 (char *) "self",(char *) "deleteWindows", NULL
39823 };
39824
39825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39827 if (SWIG_arg_fail(1)) SWIG_fail;
39828 if (obj1) {
39829 {
39830 arg2 = (bool)(SWIG_As_bool(obj1));
39831 if (SWIG_arg_fail(2)) SWIG_fail;
39832 }
39833 }
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 (arg1)->Clear(arg2);
39837
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 Py_INCREF(Py_None); resultobj = Py_None;
39842 return resultobj;
39843 fail:
39844 return NULL;
39845 }
39846
39847
39848 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39849 PyObject *resultobj;
39850 wxSizer *arg1 = (wxSizer *) 0 ;
39851 PyObject * obj0 = 0 ;
39852 char *kwnames[] = {
39853 (char *) "self", NULL
39854 };
39855
39856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39858 if (SWIG_arg_fail(1)) SWIG_fail;
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 (arg1)->DeleteWindows();
39862
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 Py_INCREF(Py_None); resultobj = Py_None;
39867 return resultobj;
39868 fail:
39869 return NULL;
39870 }
39871
39872
39873 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39874 PyObject *resultobj;
39875 wxSizer *arg1 = (wxSizer *) 0 ;
39876 PyObject *result;
39877 PyObject * obj0 = 0 ;
39878 char *kwnames[] = {
39879 (char *) "self", NULL
39880 };
39881
39882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39884 if (SWIG_arg_fail(1)) SWIG_fail;
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (PyObject *)wxSizer_GetChildren(arg1);
39888
39889 wxPyEndAllowThreads(__tstate);
39890 if (PyErr_Occurred()) SWIG_fail;
39891 }
39892 resultobj = result;
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj;
39901 wxSizer *arg1 = (wxSizer *) 0 ;
39902 PyObject *arg2 = (PyObject *) 0 ;
39903 bool arg3 = (bool) true ;
39904 bool arg4 = (bool) false ;
39905 bool result;
39906 PyObject * obj0 = 0 ;
39907 PyObject * obj1 = 0 ;
39908 PyObject * obj2 = 0 ;
39909 PyObject * obj3 = 0 ;
39910 char *kwnames[] = {
39911 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39912 };
39913
39914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39916 if (SWIG_arg_fail(1)) SWIG_fail;
39917 arg2 = obj1;
39918 if (obj2) {
39919 {
39920 arg3 = (bool)(SWIG_As_bool(obj2));
39921 if (SWIG_arg_fail(3)) SWIG_fail;
39922 }
39923 }
39924 if (obj3) {
39925 {
39926 arg4 = (bool)(SWIG_As_bool(obj3));
39927 if (SWIG_arg_fail(4)) SWIG_fail;
39928 }
39929 }
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 {
39938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39939 }
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxSizer *arg1 = (wxSizer *) 0 ;
39949 PyObject *arg2 = (PyObject *) 0 ;
39950 bool result;
39951 PyObject * obj0 = 0 ;
39952 PyObject * obj1 = 0 ;
39953 char *kwnames[] = {
39954 (char *) "self",(char *) "item", NULL
39955 };
39956
39957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39959 if (SWIG_arg_fail(1)) SWIG_fail;
39960 arg2 = obj1;
39961 {
39962 PyThreadState* __tstate = wxPyBeginAllowThreads();
39963 result = (bool)wxSizer_IsShown(arg1,arg2);
39964
39965 wxPyEndAllowThreads(__tstate);
39966 if (PyErr_Occurred()) SWIG_fail;
39967 }
39968 {
39969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39970 }
39971 return resultobj;
39972 fail:
39973 return NULL;
39974 }
39975
39976
39977 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39978 PyObject *resultobj;
39979 wxSizer *arg1 = (wxSizer *) 0 ;
39980 bool arg2 ;
39981 PyObject * obj0 = 0 ;
39982 PyObject * obj1 = 0 ;
39983 char *kwnames[] = {
39984 (char *) "self",(char *) "show", NULL
39985 };
39986
39987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39989 if (SWIG_arg_fail(1)) SWIG_fail;
39990 {
39991 arg2 = (bool)(SWIG_As_bool(obj1));
39992 if (SWIG_arg_fail(2)) SWIG_fail;
39993 }
39994 {
39995 PyThreadState* __tstate = wxPyBeginAllowThreads();
39996 (arg1)->ShowItems(arg2);
39997
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 Py_INCREF(Py_None); resultobj = Py_None;
40002 return resultobj;
40003 fail:
40004 return NULL;
40005 }
40006
40007
40008 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40009 PyObject *obj;
40010 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40011 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40012 Py_INCREF(obj);
40013 return Py_BuildValue((char *)"");
40014 }
40015 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40016 PyObject *resultobj;
40017 wxPySizer *result;
40018 char *kwnames[] = {
40019 NULL
40020 };
40021
40022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40023 {
40024 PyThreadState* __tstate = wxPyBeginAllowThreads();
40025 result = (wxPySizer *)new wxPySizer();
40026
40027 wxPyEndAllowThreads(__tstate);
40028 if (PyErr_Occurred()) SWIG_fail;
40029 }
40030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40031 return resultobj;
40032 fail:
40033 return NULL;
40034 }
40035
40036
40037 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40038 PyObject *resultobj;
40039 wxPySizer *arg1 = (wxPySizer *) 0 ;
40040 PyObject *arg2 = (PyObject *) 0 ;
40041 PyObject *arg3 = (PyObject *) 0 ;
40042 PyObject * obj0 = 0 ;
40043 PyObject * obj1 = 0 ;
40044 PyObject * obj2 = 0 ;
40045 char *kwnames[] = {
40046 (char *) "self",(char *) "self",(char *) "_class", NULL
40047 };
40048
40049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40051 if (SWIG_arg_fail(1)) SWIG_fail;
40052 arg2 = obj1;
40053 arg3 = obj2;
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 (arg1)->_setCallbackInfo(arg2,arg3);
40057
40058 wxPyEndAllowThreads(__tstate);
40059 if (PyErr_Occurred()) SWIG_fail;
40060 }
40061 Py_INCREF(Py_None); resultobj = Py_None;
40062 return resultobj;
40063 fail:
40064 return NULL;
40065 }
40066
40067
40068 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40069 PyObject *obj;
40070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40071 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40072 Py_INCREF(obj);
40073 return Py_BuildValue((char *)"");
40074 }
40075 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40076 PyObject *resultobj;
40077 int arg1 = (int) wxHORIZONTAL ;
40078 wxBoxSizer *result;
40079 PyObject * obj0 = 0 ;
40080 char *kwnames[] = {
40081 (char *) "orient", NULL
40082 };
40083
40084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40085 if (obj0) {
40086 {
40087 arg1 = (int)(SWIG_As_int(obj0));
40088 if (SWIG_arg_fail(1)) SWIG_fail;
40089 }
40090 }
40091 {
40092 PyThreadState* __tstate = wxPyBeginAllowThreads();
40093 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40094
40095 wxPyEndAllowThreads(__tstate);
40096 if (PyErr_Occurred()) SWIG_fail;
40097 }
40098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40099 return resultobj;
40100 fail:
40101 return NULL;
40102 }
40103
40104
40105 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40106 PyObject *resultobj;
40107 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40108 int result;
40109 PyObject * obj0 = 0 ;
40110 char *kwnames[] = {
40111 (char *) "self", NULL
40112 };
40113
40114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40116 if (SWIG_arg_fail(1)) SWIG_fail;
40117 {
40118 PyThreadState* __tstate = wxPyBeginAllowThreads();
40119 result = (int)(arg1)->GetOrientation();
40120
40121 wxPyEndAllowThreads(__tstate);
40122 if (PyErr_Occurred()) SWIG_fail;
40123 }
40124 {
40125 resultobj = SWIG_From_int((int)(result));
40126 }
40127 return resultobj;
40128 fail:
40129 return NULL;
40130 }
40131
40132
40133 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40134 PyObject *resultobj;
40135 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40136 int arg2 ;
40137 PyObject * obj0 = 0 ;
40138 PyObject * obj1 = 0 ;
40139 char *kwnames[] = {
40140 (char *) "self",(char *) "orient", NULL
40141 };
40142
40143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40145 if (SWIG_arg_fail(1)) SWIG_fail;
40146 {
40147 arg2 = (int)(SWIG_As_int(obj1));
40148 if (SWIG_arg_fail(2)) SWIG_fail;
40149 }
40150 {
40151 PyThreadState* __tstate = wxPyBeginAllowThreads();
40152 (arg1)->SetOrientation(arg2);
40153
40154 wxPyEndAllowThreads(__tstate);
40155 if (PyErr_Occurred()) SWIG_fail;
40156 }
40157 Py_INCREF(Py_None); resultobj = Py_None;
40158 return resultobj;
40159 fail:
40160 return NULL;
40161 }
40162
40163
40164 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40165 PyObject *obj;
40166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40167 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40168 Py_INCREF(obj);
40169 return Py_BuildValue((char *)"");
40170 }
40171 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj;
40173 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40174 int arg2 = (int) wxHORIZONTAL ;
40175 wxStaticBoxSizer *result;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 char *kwnames[] = {
40179 (char *) "box",(char *) "orient", NULL
40180 };
40181
40182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40184 if (SWIG_arg_fail(1)) SWIG_fail;
40185 if (obj1) {
40186 {
40187 arg2 = (int)(SWIG_As_int(obj1));
40188 if (SWIG_arg_fail(2)) SWIG_fail;
40189 }
40190 }
40191 {
40192 PyThreadState* __tstate = wxPyBeginAllowThreads();
40193 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40194
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40199 return resultobj;
40200 fail:
40201 return NULL;
40202 }
40203
40204
40205 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40206 PyObject *resultobj;
40207 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40208 wxStaticBox *result;
40209 PyObject * obj0 = 0 ;
40210 char *kwnames[] = {
40211 (char *) "self", NULL
40212 };
40213
40214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40216 if (SWIG_arg_fail(1)) SWIG_fail;
40217 {
40218 PyThreadState* __tstate = wxPyBeginAllowThreads();
40219 result = (wxStaticBox *)(arg1)->GetStaticBox();
40220
40221 wxPyEndAllowThreads(__tstate);
40222 if (PyErr_Occurred()) SWIG_fail;
40223 }
40224 {
40225 resultobj = wxPyMake_wxObject(result, 0);
40226 }
40227 return resultobj;
40228 fail:
40229 return NULL;
40230 }
40231
40232
40233 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40234 PyObject *obj;
40235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40236 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40237 Py_INCREF(obj);
40238 return Py_BuildValue((char *)"");
40239 }
40240 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40241 PyObject *resultobj;
40242 int arg1 = (int) 1 ;
40243 int arg2 = (int) 0 ;
40244 int arg3 = (int) 0 ;
40245 int arg4 = (int) 0 ;
40246 wxGridSizer *result;
40247 PyObject * obj0 = 0 ;
40248 PyObject * obj1 = 0 ;
40249 PyObject * obj2 = 0 ;
40250 PyObject * obj3 = 0 ;
40251 char *kwnames[] = {
40252 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40253 };
40254
40255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40256 if (obj0) {
40257 {
40258 arg1 = (int)(SWIG_As_int(obj0));
40259 if (SWIG_arg_fail(1)) SWIG_fail;
40260 }
40261 }
40262 if (obj1) {
40263 {
40264 arg2 = (int)(SWIG_As_int(obj1));
40265 if (SWIG_arg_fail(2)) SWIG_fail;
40266 }
40267 }
40268 if (obj2) {
40269 {
40270 arg3 = (int)(SWIG_As_int(obj2));
40271 if (SWIG_arg_fail(3)) SWIG_fail;
40272 }
40273 }
40274 if (obj3) {
40275 {
40276 arg4 = (int)(SWIG_As_int(obj3));
40277 if (SWIG_arg_fail(4)) SWIG_fail;
40278 }
40279 }
40280 {
40281 PyThreadState* __tstate = wxPyBeginAllowThreads();
40282 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40283
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40288 return resultobj;
40289 fail:
40290 return NULL;
40291 }
40292
40293
40294 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40295 PyObject *resultobj;
40296 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40297 int arg2 ;
40298 PyObject * obj0 = 0 ;
40299 PyObject * obj1 = 0 ;
40300 char *kwnames[] = {
40301 (char *) "self",(char *) "cols", NULL
40302 };
40303
40304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40306 if (SWIG_arg_fail(1)) SWIG_fail;
40307 {
40308 arg2 = (int)(SWIG_As_int(obj1));
40309 if (SWIG_arg_fail(2)) SWIG_fail;
40310 }
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 (arg1)->SetCols(arg2);
40314
40315 wxPyEndAllowThreads(__tstate);
40316 if (PyErr_Occurred()) SWIG_fail;
40317 }
40318 Py_INCREF(Py_None); resultobj = Py_None;
40319 return resultobj;
40320 fail:
40321 return NULL;
40322 }
40323
40324
40325 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40326 PyObject *resultobj;
40327 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40328 int arg2 ;
40329 PyObject * obj0 = 0 ;
40330 PyObject * obj1 = 0 ;
40331 char *kwnames[] = {
40332 (char *) "self",(char *) "rows", NULL
40333 };
40334
40335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40337 if (SWIG_arg_fail(1)) SWIG_fail;
40338 {
40339 arg2 = (int)(SWIG_As_int(obj1));
40340 if (SWIG_arg_fail(2)) SWIG_fail;
40341 }
40342 {
40343 PyThreadState* __tstate = wxPyBeginAllowThreads();
40344 (arg1)->SetRows(arg2);
40345
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 Py_INCREF(Py_None); resultobj = Py_None;
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj;
40358 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40359 int arg2 ;
40360 PyObject * obj0 = 0 ;
40361 PyObject * obj1 = 0 ;
40362 char *kwnames[] = {
40363 (char *) "self",(char *) "gap", NULL
40364 };
40365
40366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40368 if (SWIG_arg_fail(1)) SWIG_fail;
40369 {
40370 arg2 = (int)(SWIG_As_int(obj1));
40371 if (SWIG_arg_fail(2)) SWIG_fail;
40372 }
40373 {
40374 PyThreadState* __tstate = wxPyBeginAllowThreads();
40375 (arg1)->SetVGap(arg2);
40376
40377 wxPyEndAllowThreads(__tstate);
40378 if (PyErr_Occurred()) SWIG_fail;
40379 }
40380 Py_INCREF(Py_None); resultobj = Py_None;
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40388 PyObject *resultobj;
40389 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40390 int arg2 ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 char *kwnames[] = {
40394 (char *) "self",(char *) "gap", NULL
40395 };
40396
40397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40399 if (SWIG_arg_fail(1)) SWIG_fail;
40400 {
40401 arg2 = (int)(SWIG_As_int(obj1));
40402 if (SWIG_arg_fail(2)) SWIG_fail;
40403 }
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 (arg1)->SetHGap(arg2);
40407
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 Py_INCREF(Py_None); resultobj = Py_None;
40412 return resultobj;
40413 fail:
40414 return NULL;
40415 }
40416
40417
40418 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40419 PyObject *resultobj;
40420 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40421 int result;
40422 PyObject * obj0 = 0 ;
40423 char *kwnames[] = {
40424 (char *) "self", NULL
40425 };
40426
40427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40429 if (SWIG_arg_fail(1)) SWIG_fail;
40430 {
40431 PyThreadState* __tstate = wxPyBeginAllowThreads();
40432 result = (int)(arg1)->GetCols();
40433
40434 wxPyEndAllowThreads(__tstate);
40435 if (PyErr_Occurred()) SWIG_fail;
40436 }
40437 {
40438 resultobj = SWIG_From_int((int)(result));
40439 }
40440 return resultobj;
40441 fail:
40442 return NULL;
40443 }
40444
40445
40446 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40447 PyObject *resultobj;
40448 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40449 int result;
40450 PyObject * obj0 = 0 ;
40451 char *kwnames[] = {
40452 (char *) "self", NULL
40453 };
40454
40455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40457 if (SWIG_arg_fail(1)) SWIG_fail;
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 result = (int)(arg1)->GetRows();
40461
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 {
40466 resultobj = SWIG_From_int((int)(result));
40467 }
40468 return resultobj;
40469 fail:
40470 return NULL;
40471 }
40472
40473
40474 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40475 PyObject *resultobj;
40476 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40477 int result;
40478 PyObject * obj0 = 0 ;
40479 char *kwnames[] = {
40480 (char *) "self", NULL
40481 };
40482
40483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40485 if (SWIG_arg_fail(1)) SWIG_fail;
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = (int)(arg1)->GetVGap();
40489
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 resultobj = SWIG_From_int((int)(result));
40495 }
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40503 PyObject *resultobj;
40504 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40505 int result;
40506 PyObject * obj0 = 0 ;
40507 char *kwnames[] = {
40508 (char *) "self", NULL
40509 };
40510
40511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40513 if (SWIG_arg_fail(1)) SWIG_fail;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (int)(arg1)->GetHGap();
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = SWIG_From_int((int)(result));
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40531 PyObject *obj;
40532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40533 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40534 Py_INCREF(obj);
40535 return Py_BuildValue((char *)"");
40536 }
40537 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40538 PyObject *resultobj;
40539 int arg1 = (int) 1 ;
40540 int arg2 = (int) 0 ;
40541 int arg3 = (int) 0 ;
40542 int arg4 = (int) 0 ;
40543 wxFlexGridSizer *result;
40544 PyObject * obj0 = 0 ;
40545 PyObject * obj1 = 0 ;
40546 PyObject * obj2 = 0 ;
40547 PyObject * obj3 = 0 ;
40548 char *kwnames[] = {
40549 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40550 };
40551
40552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40553 if (obj0) {
40554 {
40555 arg1 = (int)(SWIG_As_int(obj0));
40556 if (SWIG_arg_fail(1)) SWIG_fail;
40557 }
40558 }
40559 if (obj1) {
40560 {
40561 arg2 = (int)(SWIG_As_int(obj1));
40562 if (SWIG_arg_fail(2)) SWIG_fail;
40563 }
40564 }
40565 if (obj2) {
40566 {
40567 arg3 = (int)(SWIG_As_int(obj2));
40568 if (SWIG_arg_fail(3)) SWIG_fail;
40569 }
40570 }
40571 if (obj3) {
40572 {
40573 arg4 = (int)(SWIG_As_int(obj3));
40574 if (SWIG_arg_fail(4)) SWIG_fail;
40575 }
40576 }
40577 {
40578 PyThreadState* __tstate = wxPyBeginAllowThreads();
40579 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40580
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40585 return resultobj;
40586 fail:
40587 return NULL;
40588 }
40589
40590
40591 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40592 PyObject *resultobj;
40593 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40594 size_t arg2 ;
40595 int arg3 = (int) 0 ;
40596 PyObject * obj0 = 0 ;
40597 PyObject * obj1 = 0 ;
40598 PyObject * obj2 = 0 ;
40599 char *kwnames[] = {
40600 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40601 };
40602
40603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40605 if (SWIG_arg_fail(1)) SWIG_fail;
40606 {
40607 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40608 if (SWIG_arg_fail(2)) SWIG_fail;
40609 }
40610 if (obj2) {
40611 {
40612 arg3 = (int)(SWIG_As_int(obj2));
40613 if (SWIG_arg_fail(3)) SWIG_fail;
40614 }
40615 }
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 (arg1)->AddGrowableRow(arg2,arg3);
40619
40620 wxPyEndAllowThreads(__tstate);
40621 if (PyErr_Occurred()) SWIG_fail;
40622 }
40623 Py_INCREF(Py_None); resultobj = Py_None;
40624 return resultobj;
40625 fail:
40626 return NULL;
40627 }
40628
40629
40630 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40631 PyObject *resultobj;
40632 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40633 size_t arg2 ;
40634 PyObject * obj0 = 0 ;
40635 PyObject * obj1 = 0 ;
40636 char *kwnames[] = {
40637 (char *) "self",(char *) "idx", NULL
40638 };
40639
40640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40642 if (SWIG_arg_fail(1)) SWIG_fail;
40643 {
40644 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40645 if (SWIG_arg_fail(2)) SWIG_fail;
40646 }
40647 {
40648 PyThreadState* __tstate = wxPyBeginAllowThreads();
40649 (arg1)->RemoveGrowableRow(arg2);
40650
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 Py_INCREF(Py_None); resultobj = Py_None;
40655 return resultobj;
40656 fail:
40657 return NULL;
40658 }
40659
40660
40661 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40662 PyObject *resultobj;
40663 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40664 size_t arg2 ;
40665 int arg3 = (int) 0 ;
40666 PyObject * obj0 = 0 ;
40667 PyObject * obj1 = 0 ;
40668 PyObject * obj2 = 0 ;
40669 char *kwnames[] = {
40670 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40671 };
40672
40673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40675 if (SWIG_arg_fail(1)) SWIG_fail;
40676 {
40677 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40678 if (SWIG_arg_fail(2)) SWIG_fail;
40679 }
40680 if (obj2) {
40681 {
40682 arg3 = (int)(SWIG_As_int(obj2));
40683 if (SWIG_arg_fail(3)) SWIG_fail;
40684 }
40685 }
40686 {
40687 PyThreadState* __tstate = wxPyBeginAllowThreads();
40688 (arg1)->AddGrowableCol(arg2,arg3);
40689
40690 wxPyEndAllowThreads(__tstate);
40691 if (PyErr_Occurred()) SWIG_fail;
40692 }
40693 Py_INCREF(Py_None); resultobj = Py_None;
40694 return resultobj;
40695 fail:
40696 return NULL;
40697 }
40698
40699
40700 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40701 PyObject *resultobj;
40702 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40703 size_t arg2 ;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 char *kwnames[] = {
40707 (char *) "self",(char *) "idx", NULL
40708 };
40709
40710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40712 if (SWIG_arg_fail(1)) SWIG_fail;
40713 {
40714 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40715 if (SWIG_arg_fail(2)) SWIG_fail;
40716 }
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 (arg1)->RemoveGrowableCol(arg2);
40720
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 Py_INCREF(Py_None); resultobj = Py_None;
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40732 PyObject *resultobj;
40733 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40734 int arg2 ;
40735 PyObject * obj0 = 0 ;
40736 PyObject * obj1 = 0 ;
40737 char *kwnames[] = {
40738 (char *) "self",(char *) "direction", NULL
40739 };
40740
40741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40743 if (SWIG_arg_fail(1)) SWIG_fail;
40744 {
40745 arg2 = (int)(SWIG_As_int(obj1));
40746 if (SWIG_arg_fail(2)) SWIG_fail;
40747 }
40748 {
40749 PyThreadState* __tstate = wxPyBeginAllowThreads();
40750 (arg1)->SetFlexibleDirection(arg2);
40751
40752 wxPyEndAllowThreads(__tstate);
40753 if (PyErr_Occurred()) SWIG_fail;
40754 }
40755 Py_INCREF(Py_None); resultobj = Py_None;
40756 return resultobj;
40757 fail:
40758 return NULL;
40759 }
40760
40761
40762 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40763 PyObject *resultobj;
40764 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40765 int result;
40766 PyObject * obj0 = 0 ;
40767 char *kwnames[] = {
40768 (char *) "self", NULL
40769 };
40770
40771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40773 if (SWIG_arg_fail(1)) SWIG_fail;
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 result = (int)(arg1)->GetFlexibleDirection();
40777
40778 wxPyEndAllowThreads(__tstate);
40779 if (PyErr_Occurred()) SWIG_fail;
40780 }
40781 {
40782 resultobj = SWIG_From_int((int)(result));
40783 }
40784 return resultobj;
40785 fail:
40786 return NULL;
40787 }
40788
40789
40790 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40791 PyObject *resultobj;
40792 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40793 wxFlexSizerGrowMode arg2 ;
40794 PyObject * obj0 = 0 ;
40795 PyObject * obj1 = 0 ;
40796 char *kwnames[] = {
40797 (char *) "self",(char *) "mode", NULL
40798 };
40799
40800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40802 if (SWIG_arg_fail(1)) SWIG_fail;
40803 {
40804 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40805 if (SWIG_arg_fail(2)) SWIG_fail;
40806 }
40807 {
40808 PyThreadState* __tstate = wxPyBeginAllowThreads();
40809 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40810
40811 wxPyEndAllowThreads(__tstate);
40812 if (PyErr_Occurred()) SWIG_fail;
40813 }
40814 Py_INCREF(Py_None); resultobj = Py_None;
40815 return resultobj;
40816 fail:
40817 return NULL;
40818 }
40819
40820
40821 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj;
40823 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40824 wxFlexSizerGrowMode result;
40825 PyObject * obj0 = 0 ;
40826 char *kwnames[] = {
40827 (char *) "self", NULL
40828 };
40829
40830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40832 if (SWIG_arg_fail(1)) SWIG_fail;
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40836
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 resultobj = SWIG_From_int((result));
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40850 wxArrayInt *result;
40851 PyObject * obj0 = 0 ;
40852 char *kwnames[] = {
40853 (char *) "self", NULL
40854 };
40855
40856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40858 if (SWIG_arg_fail(1)) SWIG_fail;
40859 {
40860 PyThreadState* __tstate = wxPyBeginAllowThreads();
40861 {
40862 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40863 result = (wxArrayInt *) &_result_ref;
40864 }
40865
40866 wxPyEndAllowThreads(__tstate);
40867 if (PyErr_Occurred()) SWIG_fail;
40868 }
40869 {
40870 resultobj = PyList_New(0);
40871 size_t idx;
40872 for (idx = 0; idx < result->GetCount(); idx += 1) {
40873 PyObject* val = PyInt_FromLong( result->Item(idx) );
40874 PyList_Append(resultobj, val);
40875 Py_DECREF(val);
40876 }
40877 }
40878 return resultobj;
40879 fail:
40880 return NULL;
40881 }
40882
40883
40884 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40885 PyObject *resultobj;
40886 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40887 wxArrayInt *result;
40888 PyObject * obj0 = 0 ;
40889 char *kwnames[] = {
40890 (char *) "self", NULL
40891 };
40892
40893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40895 if (SWIG_arg_fail(1)) SWIG_fail;
40896 {
40897 PyThreadState* __tstate = wxPyBeginAllowThreads();
40898 {
40899 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40900 result = (wxArrayInt *) &_result_ref;
40901 }
40902
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 {
40907 resultobj = PyList_New(0);
40908 size_t idx;
40909 for (idx = 0; idx < result->GetCount(); idx += 1) {
40910 PyObject* val = PyInt_FromLong( result->Item(idx) );
40911 PyList_Append(resultobj, val);
40912 Py_DECREF(val);
40913 }
40914 }
40915 return resultobj;
40916 fail:
40917 return NULL;
40918 }
40919
40920
40921 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40922 PyObject *obj;
40923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40924 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40925 Py_INCREF(obj);
40926 return Py_BuildValue((char *)"");
40927 }
40928 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40929 PyObject *resultobj;
40930 wxStdDialogButtonSizer *result;
40931 char *kwnames[] = {
40932 NULL
40933 };
40934
40935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40936 {
40937 PyThreadState* __tstate = wxPyBeginAllowThreads();
40938 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40939
40940 wxPyEndAllowThreads(__tstate);
40941 if (PyErr_Occurred()) SWIG_fail;
40942 }
40943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40951 PyObject *resultobj;
40952 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40953 wxButton *arg2 = (wxButton *) 0 ;
40954 PyObject * obj0 = 0 ;
40955 PyObject * obj1 = 0 ;
40956 char *kwnames[] = {
40957 (char *) "self",(char *) "button", NULL
40958 };
40959
40960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40962 if (SWIG_arg_fail(1)) SWIG_fail;
40963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40964 if (SWIG_arg_fail(2)) SWIG_fail;
40965 {
40966 PyThreadState* __tstate = wxPyBeginAllowThreads();
40967 (arg1)->AddButton(arg2);
40968
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 Py_INCREF(Py_None); resultobj = Py_None;
40973 return resultobj;
40974 fail:
40975 return NULL;
40976 }
40977
40978
40979 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40980 PyObject *resultobj;
40981 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40982 PyObject * obj0 = 0 ;
40983 char *kwnames[] = {
40984 (char *) "self", NULL
40985 };
40986
40987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40989 if (SWIG_arg_fail(1)) SWIG_fail;
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 (arg1)->Realize();
40993
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 Py_INCREF(Py_None); resultobj = Py_None;
40998 return resultobj;
40999 fail:
41000 return NULL;
41001 }
41002
41003
41004 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41005 PyObject *resultobj;
41006 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41007 wxButton *arg2 = (wxButton *) 0 ;
41008 PyObject * obj0 = 0 ;
41009 PyObject * obj1 = 0 ;
41010 char *kwnames[] = {
41011 (char *) "self",(char *) "button", NULL
41012 };
41013
41014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41016 if (SWIG_arg_fail(1)) SWIG_fail;
41017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41018 if (SWIG_arg_fail(2)) SWIG_fail;
41019 {
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 (arg1)->SetAffirmativeButton(arg2);
41022
41023 wxPyEndAllowThreads(__tstate);
41024 if (PyErr_Occurred()) SWIG_fail;
41025 }
41026 Py_INCREF(Py_None); resultobj = Py_None;
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj;
41035 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41036 wxButton *arg2 = (wxButton *) 0 ;
41037 PyObject * obj0 = 0 ;
41038 PyObject * obj1 = 0 ;
41039 char *kwnames[] = {
41040 (char *) "self",(char *) "button", NULL
41041 };
41042
41043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41045 if (SWIG_arg_fail(1)) SWIG_fail;
41046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41047 if (SWIG_arg_fail(2)) SWIG_fail;
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 (arg1)->SetNegativeButton(arg2);
41051
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 Py_INCREF(Py_None); resultobj = Py_None;
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj;
41064 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41065 wxButton *arg2 = (wxButton *) 0 ;
41066 PyObject * obj0 = 0 ;
41067 PyObject * obj1 = 0 ;
41068 char *kwnames[] = {
41069 (char *) "self",(char *) "button", NULL
41070 };
41071
41072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41074 if (SWIG_arg_fail(1)) SWIG_fail;
41075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41076 if (SWIG_arg_fail(2)) SWIG_fail;
41077 {
41078 PyThreadState* __tstate = wxPyBeginAllowThreads();
41079 (arg1)->SetCancelButton(arg2);
41080
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 Py_INCREF(Py_None); resultobj = Py_None;
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41092 PyObject *resultobj;
41093 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41094 wxButton *result;
41095 PyObject * obj0 = 0 ;
41096 char *kwnames[] = {
41097 (char *) "self", NULL
41098 };
41099
41100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41102 if (SWIG_arg_fail(1)) SWIG_fail;
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41106
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 {
41111 resultobj = wxPyMake_wxObject(result, 0);
41112 }
41113 return resultobj;
41114 fail:
41115 return NULL;
41116 }
41117
41118
41119 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj;
41121 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41122 wxButton *result;
41123 PyObject * obj0 = 0 ;
41124 char *kwnames[] = {
41125 (char *) "self", NULL
41126 };
41127
41128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41130 if (SWIG_arg_fail(1)) SWIG_fail;
41131 {
41132 PyThreadState* __tstate = wxPyBeginAllowThreads();
41133 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41134
41135 wxPyEndAllowThreads(__tstate);
41136 if (PyErr_Occurred()) SWIG_fail;
41137 }
41138 {
41139 resultobj = wxPyMake_wxObject(result, 0);
41140 }
41141 return resultobj;
41142 fail:
41143 return NULL;
41144 }
41145
41146
41147 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41148 PyObject *resultobj;
41149 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41150 wxButton *result;
41151 PyObject * obj0 = 0 ;
41152 char *kwnames[] = {
41153 (char *) "self", NULL
41154 };
41155
41156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(1)) SWIG_fail;
41159 {
41160 PyThreadState* __tstate = wxPyBeginAllowThreads();
41161 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41162
41163 wxPyEndAllowThreads(__tstate);
41164 if (PyErr_Occurred()) SWIG_fail;
41165 }
41166 {
41167 resultobj = wxPyMake_wxObject(result, 0);
41168 }
41169 return resultobj;
41170 fail:
41171 return NULL;
41172 }
41173
41174
41175 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41176 PyObject *resultobj;
41177 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41178 wxButton *result;
41179 PyObject * obj0 = 0 ;
41180 char *kwnames[] = {
41181 (char *) "self", NULL
41182 };
41183
41184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41186 if (SWIG_arg_fail(1)) SWIG_fail;
41187 {
41188 PyThreadState* __tstate = wxPyBeginAllowThreads();
41189 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41190
41191 wxPyEndAllowThreads(__tstate);
41192 if (PyErr_Occurred()) SWIG_fail;
41193 }
41194 {
41195 resultobj = wxPyMake_wxObject(result, 0);
41196 }
41197 return resultobj;
41198 fail:
41199 return NULL;
41200 }
41201
41202
41203 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41204 PyObject *resultobj;
41205 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41206 wxButton *result;
41207 PyObject * obj0 = 0 ;
41208 char *kwnames[] = {
41209 (char *) "self", NULL
41210 };
41211
41212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41214 if (SWIG_arg_fail(1)) SWIG_fail;
41215 {
41216 PyThreadState* __tstate = wxPyBeginAllowThreads();
41217 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41218
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 {
41223 resultobj = wxPyMake_wxObject(result, 0);
41224 }
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41232 PyObject *obj;
41233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41234 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41235 Py_INCREF(obj);
41236 return Py_BuildValue((char *)"");
41237 }
41238 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj;
41240 int arg1 = (int) 0 ;
41241 int arg2 = (int) 0 ;
41242 wxGBPosition *result;
41243 PyObject * obj0 = 0 ;
41244 PyObject * obj1 = 0 ;
41245 char *kwnames[] = {
41246 (char *) "row",(char *) "col", NULL
41247 };
41248
41249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41250 if (obj0) {
41251 {
41252 arg1 = (int)(SWIG_As_int(obj0));
41253 if (SWIG_arg_fail(1)) SWIG_fail;
41254 }
41255 }
41256 if (obj1) {
41257 {
41258 arg2 = (int)(SWIG_As_int(obj1));
41259 if (SWIG_arg_fail(2)) SWIG_fail;
41260 }
41261 }
41262 {
41263 PyThreadState* __tstate = wxPyBeginAllowThreads();
41264 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41265
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41270 return resultobj;
41271 fail:
41272 return NULL;
41273 }
41274
41275
41276 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41277 PyObject *resultobj;
41278 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41279 int result;
41280 PyObject * obj0 = 0 ;
41281 char *kwnames[] = {
41282 (char *) "self", NULL
41283 };
41284
41285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41287 if (SWIG_arg_fail(1)) SWIG_fail;
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 result = (int)((wxGBPosition const *)arg1)->GetRow();
41291
41292 wxPyEndAllowThreads(__tstate);
41293 if (PyErr_Occurred()) SWIG_fail;
41294 }
41295 {
41296 resultobj = SWIG_From_int((int)(result));
41297 }
41298 return resultobj;
41299 fail:
41300 return NULL;
41301 }
41302
41303
41304 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41305 PyObject *resultobj;
41306 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41307 int result;
41308 PyObject * obj0 = 0 ;
41309 char *kwnames[] = {
41310 (char *) "self", NULL
41311 };
41312
41313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41315 if (SWIG_arg_fail(1)) SWIG_fail;
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (int)((wxGBPosition const *)arg1)->GetCol();
41319
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 {
41324 resultobj = SWIG_From_int((int)(result));
41325 }
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41333 PyObject *resultobj;
41334 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41335 int arg2 ;
41336 PyObject * obj0 = 0 ;
41337 PyObject * obj1 = 0 ;
41338 char *kwnames[] = {
41339 (char *) "self",(char *) "row", NULL
41340 };
41341
41342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41344 if (SWIG_arg_fail(1)) SWIG_fail;
41345 {
41346 arg2 = (int)(SWIG_As_int(obj1));
41347 if (SWIG_arg_fail(2)) SWIG_fail;
41348 }
41349 {
41350 PyThreadState* __tstate = wxPyBeginAllowThreads();
41351 (arg1)->SetRow(arg2);
41352
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 Py_INCREF(Py_None); resultobj = Py_None;
41357 return resultobj;
41358 fail:
41359 return NULL;
41360 }
41361
41362
41363 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41364 PyObject *resultobj;
41365 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41366 int arg2 ;
41367 PyObject * obj0 = 0 ;
41368 PyObject * obj1 = 0 ;
41369 char *kwnames[] = {
41370 (char *) "self",(char *) "col", NULL
41371 };
41372
41373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41375 if (SWIG_arg_fail(1)) SWIG_fail;
41376 {
41377 arg2 = (int)(SWIG_As_int(obj1));
41378 if (SWIG_arg_fail(2)) SWIG_fail;
41379 }
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 (arg1)->SetCol(arg2);
41383
41384 wxPyEndAllowThreads(__tstate);
41385 if (PyErr_Occurred()) SWIG_fail;
41386 }
41387 Py_INCREF(Py_None); resultobj = Py_None;
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj;
41396 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41397 wxGBPosition *arg2 = 0 ;
41398 bool result;
41399 wxGBPosition temp2 ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 char *kwnames[] = {
41403 (char *) "self",(char *) "other", NULL
41404 };
41405
41406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41408 if (SWIG_arg_fail(1)) SWIG_fail;
41409 {
41410 arg2 = &temp2;
41411 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41412 }
41413 {
41414 PyThreadState* __tstate = wxPyBeginAllowThreads();
41415 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41416
41417 wxPyEndAllowThreads(__tstate);
41418 if (PyErr_Occurred()) SWIG_fail;
41419 }
41420 {
41421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41422 }
41423 return resultobj;
41424 fail:
41425 return NULL;
41426 }
41427
41428
41429 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41430 PyObject *resultobj;
41431 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41432 wxGBPosition *arg2 = 0 ;
41433 bool result;
41434 wxGBPosition temp2 ;
41435 PyObject * obj0 = 0 ;
41436 PyObject * obj1 = 0 ;
41437 char *kwnames[] = {
41438 (char *) "self",(char *) "other", NULL
41439 };
41440
41441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41443 if (SWIG_arg_fail(1)) SWIG_fail;
41444 {
41445 arg2 = &temp2;
41446 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41447 }
41448 {
41449 PyThreadState* __tstate = wxPyBeginAllowThreads();
41450 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41451
41452 wxPyEndAllowThreads(__tstate);
41453 if (PyErr_Occurred()) SWIG_fail;
41454 }
41455 {
41456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41457 }
41458 return resultobj;
41459 fail:
41460 return NULL;
41461 }
41462
41463
41464 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41465 PyObject *resultobj;
41466 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41467 int arg2 = (int) 0 ;
41468 int arg3 = (int) 0 ;
41469 PyObject * obj0 = 0 ;
41470 PyObject * obj1 = 0 ;
41471 PyObject * obj2 = 0 ;
41472 char *kwnames[] = {
41473 (char *) "self",(char *) "row",(char *) "col", NULL
41474 };
41475
41476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41478 if (SWIG_arg_fail(1)) SWIG_fail;
41479 if (obj1) {
41480 {
41481 arg2 = (int)(SWIG_As_int(obj1));
41482 if (SWIG_arg_fail(2)) SWIG_fail;
41483 }
41484 }
41485 if (obj2) {
41486 {
41487 arg3 = (int)(SWIG_As_int(obj2));
41488 if (SWIG_arg_fail(3)) SWIG_fail;
41489 }
41490 }
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 wxGBPosition_Set(arg1,arg2,arg3);
41494
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 Py_INCREF(Py_None); resultobj = Py_None;
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj;
41507 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41508 PyObject *result;
41509 PyObject * obj0 = 0 ;
41510 char *kwnames[] = {
41511 (char *) "self", NULL
41512 };
41513
41514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41516 if (SWIG_arg_fail(1)) SWIG_fail;
41517 {
41518 PyThreadState* __tstate = wxPyBeginAllowThreads();
41519 result = (PyObject *)wxGBPosition_Get(arg1);
41520
41521 wxPyEndAllowThreads(__tstate);
41522 if (PyErr_Occurred()) SWIG_fail;
41523 }
41524 resultobj = result;
41525 return resultobj;
41526 fail:
41527 return NULL;
41528 }
41529
41530
41531 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41532 PyObject *obj;
41533 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41534 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41535 Py_INCREF(obj);
41536 return Py_BuildValue((char *)"");
41537 }
41538 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj;
41540 int arg1 = (int) 1 ;
41541 int arg2 = (int) 1 ;
41542 wxGBSpan *result;
41543 PyObject * obj0 = 0 ;
41544 PyObject * obj1 = 0 ;
41545 char *kwnames[] = {
41546 (char *) "rowspan",(char *) "colspan", NULL
41547 };
41548
41549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41550 if (obj0) {
41551 {
41552 arg1 = (int)(SWIG_As_int(obj0));
41553 if (SWIG_arg_fail(1)) SWIG_fail;
41554 }
41555 }
41556 if (obj1) {
41557 {
41558 arg2 = (int)(SWIG_As_int(obj1));
41559 if (SWIG_arg_fail(2)) SWIG_fail;
41560 }
41561 }
41562 {
41563 PyThreadState* __tstate = wxPyBeginAllowThreads();
41564 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41565
41566 wxPyEndAllowThreads(__tstate);
41567 if (PyErr_Occurred()) SWIG_fail;
41568 }
41569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41570 return resultobj;
41571 fail:
41572 return NULL;
41573 }
41574
41575
41576 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41577 PyObject *resultobj;
41578 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41579 int result;
41580 PyObject * obj0 = 0 ;
41581 char *kwnames[] = {
41582 (char *) "self", NULL
41583 };
41584
41585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41587 if (SWIG_arg_fail(1)) SWIG_fail;
41588 {
41589 PyThreadState* __tstate = wxPyBeginAllowThreads();
41590 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41591
41592 wxPyEndAllowThreads(__tstate);
41593 if (PyErr_Occurred()) SWIG_fail;
41594 }
41595 {
41596 resultobj = SWIG_From_int((int)(result));
41597 }
41598 return resultobj;
41599 fail:
41600 return NULL;
41601 }
41602
41603
41604 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41605 PyObject *resultobj;
41606 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41607 int result;
41608 PyObject * obj0 = 0 ;
41609 char *kwnames[] = {
41610 (char *) "self", NULL
41611 };
41612
41613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41615 if (SWIG_arg_fail(1)) SWIG_fail;
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41619
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 {
41624 resultobj = SWIG_From_int((int)(result));
41625 }
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41633 PyObject *resultobj;
41634 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41635 int arg2 ;
41636 PyObject * obj0 = 0 ;
41637 PyObject * obj1 = 0 ;
41638 char *kwnames[] = {
41639 (char *) "self",(char *) "rowspan", NULL
41640 };
41641
41642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41644 if (SWIG_arg_fail(1)) SWIG_fail;
41645 {
41646 arg2 = (int)(SWIG_As_int(obj1));
41647 if (SWIG_arg_fail(2)) SWIG_fail;
41648 }
41649 {
41650 PyThreadState* __tstate = wxPyBeginAllowThreads();
41651 (arg1)->SetRowspan(arg2);
41652
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 Py_INCREF(Py_None); resultobj = Py_None;
41657 return resultobj;
41658 fail:
41659 return NULL;
41660 }
41661
41662
41663 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41664 PyObject *resultobj;
41665 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41666 int arg2 ;
41667 PyObject * obj0 = 0 ;
41668 PyObject * obj1 = 0 ;
41669 char *kwnames[] = {
41670 (char *) "self",(char *) "colspan", NULL
41671 };
41672
41673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41675 if (SWIG_arg_fail(1)) SWIG_fail;
41676 {
41677 arg2 = (int)(SWIG_As_int(obj1));
41678 if (SWIG_arg_fail(2)) SWIG_fail;
41679 }
41680 {
41681 PyThreadState* __tstate = wxPyBeginAllowThreads();
41682 (arg1)->SetColspan(arg2);
41683
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 Py_INCREF(Py_None); resultobj = Py_None;
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41695 PyObject *resultobj;
41696 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41697 wxGBSpan *arg2 = 0 ;
41698 bool result;
41699 wxGBSpan temp2 ;
41700 PyObject * obj0 = 0 ;
41701 PyObject * obj1 = 0 ;
41702 char *kwnames[] = {
41703 (char *) "self",(char *) "other", NULL
41704 };
41705
41706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41708 if (SWIG_arg_fail(1)) SWIG_fail;
41709 {
41710 arg2 = &temp2;
41711 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41712 }
41713 {
41714 PyThreadState* __tstate = wxPyBeginAllowThreads();
41715 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41716
41717 wxPyEndAllowThreads(__tstate);
41718 if (PyErr_Occurred()) SWIG_fail;
41719 }
41720 {
41721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41722 }
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41730 PyObject *resultobj;
41731 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41732 wxGBSpan *arg2 = 0 ;
41733 bool result;
41734 wxGBSpan temp2 ;
41735 PyObject * obj0 = 0 ;
41736 PyObject * obj1 = 0 ;
41737 char *kwnames[] = {
41738 (char *) "self",(char *) "other", NULL
41739 };
41740
41741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41743 if (SWIG_arg_fail(1)) SWIG_fail;
41744 {
41745 arg2 = &temp2;
41746 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41747 }
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41751
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41757 }
41758 return resultobj;
41759 fail:
41760 return NULL;
41761 }
41762
41763
41764 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41765 PyObject *resultobj;
41766 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41767 int arg2 = (int) 1 ;
41768 int arg3 = (int) 1 ;
41769 PyObject * obj0 = 0 ;
41770 PyObject * obj1 = 0 ;
41771 PyObject * obj2 = 0 ;
41772 char *kwnames[] = {
41773 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41774 };
41775
41776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41778 if (SWIG_arg_fail(1)) SWIG_fail;
41779 if (obj1) {
41780 {
41781 arg2 = (int)(SWIG_As_int(obj1));
41782 if (SWIG_arg_fail(2)) SWIG_fail;
41783 }
41784 }
41785 if (obj2) {
41786 {
41787 arg3 = (int)(SWIG_As_int(obj2));
41788 if (SWIG_arg_fail(3)) SWIG_fail;
41789 }
41790 }
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 wxGBSpan_Set(arg1,arg2,arg3);
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 Py_INCREF(Py_None); resultobj = Py_None;
41799 return resultobj;
41800 fail:
41801 return NULL;
41802 }
41803
41804
41805 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41806 PyObject *resultobj;
41807 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41808 PyObject *result;
41809 PyObject * obj0 = 0 ;
41810 char *kwnames[] = {
41811 (char *) "self", NULL
41812 };
41813
41814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41816 if (SWIG_arg_fail(1)) SWIG_fail;
41817 {
41818 PyThreadState* __tstate = wxPyBeginAllowThreads();
41819 result = (PyObject *)wxGBSpan_Get(arg1);
41820
41821 wxPyEndAllowThreads(__tstate);
41822 if (PyErr_Occurred()) SWIG_fail;
41823 }
41824 resultobj = result;
41825 return resultobj;
41826 fail:
41827 return NULL;
41828 }
41829
41830
41831 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41832 PyObject *obj;
41833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41834 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41835 Py_INCREF(obj);
41836 return Py_BuildValue((char *)"");
41837 }
41838 static int _wrap_DefaultSpan_set(PyObject *) {
41839 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41840 return 1;
41841 }
41842
41843
41844 static PyObject *_wrap_DefaultSpan_get(void) {
41845 PyObject *pyobj;
41846
41847 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41848 return pyobj;
41849 }
41850
41851
41852 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41853 PyObject *resultobj;
41854 wxGBSizerItem *result;
41855 char *kwnames[] = {
41856 NULL
41857 };
41858
41859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41860 {
41861 PyThreadState* __tstate = wxPyBeginAllowThreads();
41862 result = (wxGBSizerItem *)new wxGBSizerItem();
41863
41864 wxPyEndAllowThreads(__tstate);
41865 if (PyErr_Occurred()) SWIG_fail;
41866 }
41867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41868 return resultobj;
41869 fail:
41870 return NULL;
41871 }
41872
41873
41874 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41875 PyObject *resultobj;
41876 wxWindow *arg1 = (wxWindow *) 0 ;
41877 wxGBPosition *arg2 = 0 ;
41878 wxGBSpan *arg3 = 0 ;
41879 int arg4 ;
41880 int arg5 ;
41881 PyObject *arg6 = (PyObject *) NULL ;
41882 wxGBSizerItem *result;
41883 wxGBPosition temp2 ;
41884 wxGBSpan temp3 ;
41885 PyObject * obj0 = 0 ;
41886 PyObject * obj1 = 0 ;
41887 PyObject * obj2 = 0 ;
41888 PyObject * obj3 = 0 ;
41889 PyObject * obj4 = 0 ;
41890 PyObject * obj5 = 0 ;
41891 char *kwnames[] = {
41892 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41893 };
41894
41895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41897 if (SWIG_arg_fail(1)) SWIG_fail;
41898 {
41899 arg2 = &temp2;
41900 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41901 }
41902 {
41903 arg3 = &temp3;
41904 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41905 }
41906 {
41907 arg4 = (int)(SWIG_As_int(obj3));
41908 if (SWIG_arg_fail(4)) SWIG_fail;
41909 }
41910 {
41911 arg5 = (int)(SWIG_As_int(obj4));
41912 if (SWIG_arg_fail(5)) SWIG_fail;
41913 }
41914 if (obj5) {
41915 arg6 = obj5;
41916 }
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41920
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41925 return resultobj;
41926 fail:
41927 return NULL;
41928 }
41929
41930
41931 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41932 PyObject *resultobj;
41933 wxSizer *arg1 = (wxSizer *) 0 ;
41934 wxGBPosition *arg2 = 0 ;
41935 wxGBSpan *arg3 = 0 ;
41936 int arg4 ;
41937 int arg5 ;
41938 PyObject *arg6 = (PyObject *) NULL ;
41939 wxGBSizerItem *result;
41940 wxGBPosition temp2 ;
41941 wxGBSpan temp3 ;
41942 PyObject * obj0 = 0 ;
41943 PyObject * obj1 = 0 ;
41944 PyObject * obj2 = 0 ;
41945 PyObject * obj3 = 0 ;
41946 PyObject * obj4 = 0 ;
41947 PyObject * obj5 = 0 ;
41948 char *kwnames[] = {
41949 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41950 };
41951
41952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41954 if (SWIG_arg_fail(1)) SWIG_fail;
41955 {
41956 arg2 = &temp2;
41957 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41958 }
41959 {
41960 arg3 = &temp3;
41961 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41962 }
41963 {
41964 arg4 = (int)(SWIG_As_int(obj3));
41965 if (SWIG_arg_fail(4)) SWIG_fail;
41966 }
41967 {
41968 arg5 = (int)(SWIG_As_int(obj4));
41969 if (SWIG_arg_fail(5)) SWIG_fail;
41970 }
41971 if (obj5) {
41972 arg6 = obj5;
41973 }
41974 {
41975 PyThreadState* __tstate = wxPyBeginAllowThreads();
41976 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41977
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41982 return resultobj;
41983 fail:
41984 return NULL;
41985 }
41986
41987
41988 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41989 PyObject *resultobj;
41990 int arg1 ;
41991 int arg2 ;
41992 wxGBPosition *arg3 = 0 ;
41993 wxGBSpan *arg4 = 0 ;
41994 int arg5 ;
41995 int arg6 ;
41996 PyObject *arg7 = (PyObject *) NULL ;
41997 wxGBSizerItem *result;
41998 wxGBPosition temp3 ;
41999 wxGBSpan temp4 ;
42000 PyObject * obj0 = 0 ;
42001 PyObject * obj1 = 0 ;
42002 PyObject * obj2 = 0 ;
42003 PyObject * obj3 = 0 ;
42004 PyObject * obj4 = 0 ;
42005 PyObject * obj5 = 0 ;
42006 PyObject * obj6 = 0 ;
42007 char *kwnames[] = {
42008 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42009 };
42010
42011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42012 {
42013 arg1 = (int)(SWIG_As_int(obj0));
42014 if (SWIG_arg_fail(1)) SWIG_fail;
42015 }
42016 {
42017 arg2 = (int)(SWIG_As_int(obj1));
42018 if (SWIG_arg_fail(2)) SWIG_fail;
42019 }
42020 {
42021 arg3 = &temp3;
42022 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42023 }
42024 {
42025 arg4 = &temp4;
42026 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42027 }
42028 {
42029 arg5 = (int)(SWIG_As_int(obj4));
42030 if (SWIG_arg_fail(5)) SWIG_fail;
42031 }
42032 {
42033 arg6 = (int)(SWIG_As_int(obj5));
42034 if (SWIG_arg_fail(6)) SWIG_fail;
42035 }
42036 if (obj6) {
42037 arg7 = obj6;
42038 }
42039 {
42040 PyThreadState* __tstate = wxPyBeginAllowThreads();
42041 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42042
42043 wxPyEndAllowThreads(__tstate);
42044 if (PyErr_Occurred()) SWIG_fail;
42045 }
42046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42054 PyObject *resultobj;
42055 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42056 wxGBPosition result;
42057 PyObject * obj0 = 0 ;
42058 char *kwnames[] = {
42059 (char *) "self", NULL
42060 };
42061
42062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42064 if (SWIG_arg_fail(1)) SWIG_fail;
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 result = ((wxGBSizerItem const *)arg1)->GetPos();
42068
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 {
42073 wxGBPosition * resultptr;
42074 resultptr = new wxGBPosition((wxGBPosition &)(result));
42075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42076 }
42077 return resultobj;
42078 fail:
42079 return NULL;
42080 }
42081
42082
42083 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42084 PyObject *resultobj;
42085 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42086 wxGBSpan result;
42087 PyObject * obj0 = 0 ;
42088 char *kwnames[] = {
42089 (char *) "self", NULL
42090 };
42091
42092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42094 if (SWIG_arg_fail(1)) SWIG_fail;
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42098
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 {
42103 wxGBSpan * resultptr;
42104 resultptr = new wxGBSpan((wxGBSpan &)(result));
42105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42106 }
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42114 PyObject *resultobj;
42115 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42116 wxGBPosition *arg2 = 0 ;
42117 bool result;
42118 wxGBPosition temp2 ;
42119 PyObject * obj0 = 0 ;
42120 PyObject * obj1 = 0 ;
42121 char *kwnames[] = {
42122 (char *) "self",(char *) "pos", NULL
42123 };
42124
42125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42127 if (SWIG_arg_fail(1)) SWIG_fail;
42128 {
42129 arg2 = &temp2;
42130 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42131 }
42132 {
42133 PyThreadState* __tstate = wxPyBeginAllowThreads();
42134 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42135
42136 wxPyEndAllowThreads(__tstate);
42137 if (PyErr_Occurred()) SWIG_fail;
42138 }
42139 {
42140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42141 }
42142 return resultobj;
42143 fail:
42144 return NULL;
42145 }
42146
42147
42148 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42149 PyObject *resultobj;
42150 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42151 wxGBSpan *arg2 = 0 ;
42152 bool result;
42153 wxGBSpan temp2 ;
42154 PyObject * obj0 = 0 ;
42155 PyObject * obj1 = 0 ;
42156 char *kwnames[] = {
42157 (char *) "self",(char *) "span", NULL
42158 };
42159
42160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42162 if (SWIG_arg_fail(1)) SWIG_fail;
42163 {
42164 arg2 = &temp2;
42165 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42166 }
42167 {
42168 PyThreadState* __tstate = wxPyBeginAllowThreads();
42169 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42170
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 {
42175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42176 }
42177 return resultobj;
42178 fail:
42179 return NULL;
42180 }
42181
42182
42183 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42184 PyObject *resultobj;
42185 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42186 wxGBSizerItem *arg2 = 0 ;
42187 bool result;
42188 PyObject * obj0 = 0 ;
42189 PyObject * obj1 = 0 ;
42190 char *kwnames[] = {
42191 (char *) "self",(char *) "other", NULL
42192 };
42193
42194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42196 if (SWIG_arg_fail(1)) SWIG_fail;
42197 {
42198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42199 if (SWIG_arg_fail(2)) SWIG_fail;
42200 if (arg2 == NULL) {
42201 SWIG_null_ref("wxGBSizerItem");
42202 }
42203 if (SWIG_arg_fail(2)) SWIG_fail;
42204 }
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42208
42209 wxPyEndAllowThreads(__tstate);
42210 if (PyErr_Occurred()) SWIG_fail;
42211 }
42212 {
42213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42214 }
42215 return resultobj;
42216 fail:
42217 return NULL;
42218 }
42219
42220
42221 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42222 PyObject *resultobj;
42223 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42224 wxGBPosition *arg2 = 0 ;
42225 wxGBSpan *arg3 = 0 ;
42226 bool result;
42227 wxGBPosition temp2 ;
42228 wxGBSpan temp3 ;
42229 PyObject * obj0 = 0 ;
42230 PyObject * obj1 = 0 ;
42231 PyObject * obj2 = 0 ;
42232 char *kwnames[] = {
42233 (char *) "self",(char *) "pos",(char *) "span", NULL
42234 };
42235
42236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42238 if (SWIG_arg_fail(1)) SWIG_fail;
42239 {
42240 arg2 = &temp2;
42241 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42242 }
42243 {
42244 arg3 = &temp3;
42245 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42246 }
42247 {
42248 PyThreadState* __tstate = wxPyBeginAllowThreads();
42249 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42250
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 {
42255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42256 }
42257 return resultobj;
42258 fail:
42259 return NULL;
42260 }
42261
42262
42263 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42264 PyObject *resultobj;
42265 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42266 wxGBPosition result;
42267 PyObject * obj0 = 0 ;
42268 char *kwnames[] = {
42269 (char *) "self", NULL
42270 };
42271
42272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42274 if (SWIG_arg_fail(1)) SWIG_fail;
42275 {
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 result = wxGBSizerItem_GetEndPos(arg1);
42278
42279 wxPyEndAllowThreads(__tstate);
42280 if (PyErr_Occurred()) SWIG_fail;
42281 }
42282 {
42283 wxGBPosition * resultptr;
42284 resultptr = new wxGBPosition((wxGBPosition &)(result));
42285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42286 }
42287 return resultobj;
42288 fail:
42289 return NULL;
42290 }
42291
42292
42293 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42294 PyObject *resultobj;
42295 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42296 wxGridBagSizer *result;
42297 PyObject * obj0 = 0 ;
42298 char *kwnames[] = {
42299 (char *) "self", NULL
42300 };
42301
42302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42304 if (SWIG_arg_fail(1)) SWIG_fail;
42305 {
42306 PyThreadState* __tstate = wxPyBeginAllowThreads();
42307 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42308
42309 wxPyEndAllowThreads(__tstate);
42310 if (PyErr_Occurred()) SWIG_fail;
42311 }
42312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42313 return resultobj;
42314 fail:
42315 return NULL;
42316 }
42317
42318
42319 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42320 PyObject *resultobj;
42321 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42322 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42323 PyObject * obj0 = 0 ;
42324 PyObject * obj1 = 0 ;
42325 char *kwnames[] = {
42326 (char *) "self",(char *) "sizer", NULL
42327 };
42328
42329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42331 if (SWIG_arg_fail(1)) SWIG_fail;
42332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42333 if (SWIG_arg_fail(2)) SWIG_fail;
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 (arg1)->SetGBSizer(arg2);
42337
42338 wxPyEndAllowThreads(__tstate);
42339 if (PyErr_Occurred()) SWIG_fail;
42340 }
42341 Py_INCREF(Py_None); resultobj = Py_None;
42342 return resultobj;
42343 fail:
42344 return NULL;
42345 }
42346
42347
42348 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42349 PyObject *obj;
42350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42351 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42352 Py_INCREF(obj);
42353 return Py_BuildValue((char *)"");
42354 }
42355 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42356 PyObject *resultobj;
42357 int arg1 = (int) 0 ;
42358 int arg2 = (int) 0 ;
42359 wxGridBagSizer *result;
42360 PyObject * obj0 = 0 ;
42361 PyObject * obj1 = 0 ;
42362 char *kwnames[] = {
42363 (char *) "vgap",(char *) "hgap", NULL
42364 };
42365
42366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42367 if (obj0) {
42368 {
42369 arg1 = (int)(SWIG_As_int(obj0));
42370 if (SWIG_arg_fail(1)) SWIG_fail;
42371 }
42372 }
42373 if (obj1) {
42374 {
42375 arg2 = (int)(SWIG_As_int(obj1));
42376 if (SWIG_arg_fail(2)) SWIG_fail;
42377 }
42378 }
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42382
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42394 PyObject *resultobj;
42395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42396 PyObject *arg2 = (PyObject *) 0 ;
42397 wxGBPosition *arg3 = 0 ;
42398 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42399 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42400 int arg5 = (int) 0 ;
42401 int arg6 = (int) 0 ;
42402 PyObject *arg7 = (PyObject *) NULL ;
42403 wxGBSizerItem *result;
42404 wxGBPosition temp3 ;
42405 wxGBSpan temp4 ;
42406 PyObject * obj0 = 0 ;
42407 PyObject * obj1 = 0 ;
42408 PyObject * obj2 = 0 ;
42409 PyObject * obj3 = 0 ;
42410 PyObject * obj4 = 0 ;
42411 PyObject * obj5 = 0 ;
42412 PyObject * obj6 = 0 ;
42413 char *kwnames[] = {
42414 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42415 };
42416
42417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42419 if (SWIG_arg_fail(1)) SWIG_fail;
42420 arg2 = obj1;
42421 {
42422 arg3 = &temp3;
42423 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42424 }
42425 if (obj3) {
42426 {
42427 arg4 = &temp4;
42428 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42429 }
42430 }
42431 if (obj4) {
42432 {
42433 arg5 = (int)(SWIG_As_int(obj4));
42434 if (SWIG_arg_fail(5)) SWIG_fail;
42435 }
42436 }
42437 if (obj5) {
42438 {
42439 arg6 = (int)(SWIG_As_int(obj5));
42440 if (SWIG_arg_fail(6)) SWIG_fail;
42441 }
42442 }
42443 if (obj6) {
42444 arg7 = obj6;
42445 }
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42449
42450 wxPyEndAllowThreads(__tstate);
42451 if (PyErr_Occurred()) SWIG_fail;
42452 }
42453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42454 return resultobj;
42455 fail:
42456 return NULL;
42457 }
42458
42459
42460 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42461 PyObject *resultobj;
42462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42463 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42464 wxGBSizerItem *result;
42465 PyObject * obj0 = 0 ;
42466 PyObject * obj1 = 0 ;
42467 char *kwnames[] = {
42468 (char *) "self",(char *) "item", NULL
42469 };
42470
42471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42473 if (SWIG_arg_fail(1)) SWIG_fail;
42474 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42475 if (SWIG_arg_fail(2)) SWIG_fail;
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42479
42480 wxPyEndAllowThreads(__tstate);
42481 if (PyErr_Occurred()) SWIG_fail;
42482 }
42483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42484 return resultobj;
42485 fail:
42486 return NULL;
42487 }
42488
42489
42490 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42491 PyObject *resultobj;
42492 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42493 int arg2 ;
42494 int arg3 ;
42495 wxSize result;
42496 PyObject * obj0 = 0 ;
42497 PyObject * obj1 = 0 ;
42498 PyObject * obj2 = 0 ;
42499 char *kwnames[] = {
42500 (char *) "self",(char *) "row",(char *) "col", NULL
42501 };
42502
42503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42505 if (SWIG_arg_fail(1)) SWIG_fail;
42506 {
42507 arg2 = (int)(SWIG_As_int(obj1));
42508 if (SWIG_arg_fail(2)) SWIG_fail;
42509 }
42510 {
42511 arg3 = (int)(SWIG_As_int(obj2));
42512 if (SWIG_arg_fail(3)) SWIG_fail;
42513 }
42514 {
42515 PyThreadState* __tstate = wxPyBeginAllowThreads();
42516 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42517
42518 wxPyEndAllowThreads(__tstate);
42519 if (PyErr_Occurred()) SWIG_fail;
42520 }
42521 {
42522 wxSize * resultptr;
42523 resultptr = new wxSize((wxSize &)(result));
42524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42525 }
42526 return resultobj;
42527 fail:
42528 return NULL;
42529 }
42530
42531
42532 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42533 PyObject *resultobj;
42534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42535 wxSize result;
42536 PyObject * obj0 = 0 ;
42537 char *kwnames[] = {
42538 (char *) "self", NULL
42539 };
42540
42541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42543 if (SWIG_arg_fail(1)) SWIG_fail;
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42547
42548 wxPyEndAllowThreads(__tstate);
42549 if (PyErr_Occurred()) SWIG_fail;
42550 }
42551 {
42552 wxSize * resultptr;
42553 resultptr = new wxSize((wxSize &)(result));
42554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42555 }
42556 return resultobj;
42557 fail:
42558 return NULL;
42559 }
42560
42561
42562 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42563 PyObject *resultobj;
42564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42565 wxSize *arg2 = 0 ;
42566 wxSize temp2 ;
42567 PyObject * obj0 = 0 ;
42568 PyObject * obj1 = 0 ;
42569 char *kwnames[] = {
42570 (char *) "self",(char *) "sz", NULL
42571 };
42572
42573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42575 if (SWIG_arg_fail(1)) SWIG_fail;
42576 {
42577 arg2 = &temp2;
42578 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42579 }
42580 {
42581 PyThreadState* __tstate = wxPyBeginAllowThreads();
42582 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42583
42584 wxPyEndAllowThreads(__tstate);
42585 if (PyErr_Occurred()) SWIG_fail;
42586 }
42587 Py_INCREF(Py_None); resultobj = Py_None;
42588 return resultobj;
42589 fail:
42590 return NULL;
42591 }
42592
42593
42594 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42595 PyObject *resultobj;
42596 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42597 wxWindow *arg2 = (wxWindow *) 0 ;
42598 wxGBPosition result;
42599 PyObject * obj0 = 0 ;
42600 PyObject * obj1 = 0 ;
42601
42602 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42604 if (SWIG_arg_fail(1)) SWIG_fail;
42605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42606 if (SWIG_arg_fail(2)) SWIG_fail;
42607 {
42608 PyThreadState* __tstate = wxPyBeginAllowThreads();
42609 result = (arg1)->GetItemPosition(arg2);
42610
42611 wxPyEndAllowThreads(__tstate);
42612 if (PyErr_Occurred()) SWIG_fail;
42613 }
42614 {
42615 wxGBPosition * resultptr;
42616 resultptr = new wxGBPosition((wxGBPosition &)(result));
42617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42618 }
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42626 PyObject *resultobj;
42627 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42628 wxSizer *arg2 = (wxSizer *) 0 ;
42629 wxGBPosition result;
42630 PyObject * obj0 = 0 ;
42631 PyObject * obj1 = 0 ;
42632
42633 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42635 if (SWIG_arg_fail(1)) SWIG_fail;
42636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42637 if (SWIG_arg_fail(2)) SWIG_fail;
42638 {
42639 PyThreadState* __tstate = wxPyBeginAllowThreads();
42640 result = (arg1)->GetItemPosition(arg2);
42641
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 {
42646 wxGBPosition * resultptr;
42647 resultptr = new wxGBPosition((wxGBPosition &)(result));
42648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42649 }
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42657 PyObject *resultobj;
42658 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42659 size_t arg2 ;
42660 wxGBPosition result;
42661 PyObject * obj0 = 0 ;
42662 PyObject * obj1 = 0 ;
42663
42664 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42666 if (SWIG_arg_fail(1)) SWIG_fail;
42667 {
42668 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42669 if (SWIG_arg_fail(2)) SWIG_fail;
42670 }
42671 {
42672 PyThreadState* __tstate = wxPyBeginAllowThreads();
42673 result = (arg1)->GetItemPosition(arg2);
42674
42675 wxPyEndAllowThreads(__tstate);
42676 if (PyErr_Occurred()) SWIG_fail;
42677 }
42678 {
42679 wxGBPosition * resultptr;
42680 resultptr = new wxGBPosition((wxGBPosition &)(result));
42681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42682 }
42683 return resultobj;
42684 fail:
42685 return NULL;
42686 }
42687
42688
42689 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42690 int argc;
42691 PyObject *argv[3];
42692 int ii;
42693
42694 argc = PyObject_Length(args);
42695 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42696 argv[ii] = PyTuple_GetItem(args,ii);
42697 }
42698 if (argc == 2) {
42699 int _v;
42700 {
42701 void *ptr;
42702 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42703 _v = 0;
42704 PyErr_Clear();
42705 } else {
42706 _v = 1;
42707 }
42708 }
42709 if (_v) {
42710 {
42711 void *ptr;
42712 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42713 _v = 0;
42714 PyErr_Clear();
42715 } else {
42716 _v = 1;
42717 }
42718 }
42719 if (_v) {
42720 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42721 }
42722 }
42723 }
42724 if (argc == 2) {
42725 int _v;
42726 {
42727 void *ptr;
42728 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42729 _v = 0;
42730 PyErr_Clear();
42731 } else {
42732 _v = 1;
42733 }
42734 }
42735 if (_v) {
42736 {
42737 void *ptr;
42738 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42739 _v = 0;
42740 PyErr_Clear();
42741 } else {
42742 _v = 1;
42743 }
42744 }
42745 if (_v) {
42746 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42747 }
42748 }
42749 }
42750 if (argc == 2) {
42751 int _v;
42752 {
42753 void *ptr;
42754 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42755 _v = 0;
42756 PyErr_Clear();
42757 } else {
42758 _v = 1;
42759 }
42760 }
42761 if (_v) {
42762 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42763 if (_v) {
42764 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42765 }
42766 }
42767 }
42768
42769 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42770 return NULL;
42771 }
42772
42773
42774 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42775 PyObject *resultobj;
42776 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42777 wxWindow *arg2 = (wxWindow *) 0 ;
42778 wxGBPosition *arg3 = 0 ;
42779 bool result;
42780 wxGBPosition temp3 ;
42781 PyObject * obj0 = 0 ;
42782 PyObject * obj1 = 0 ;
42783 PyObject * obj2 = 0 ;
42784
42785 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42787 if (SWIG_arg_fail(1)) SWIG_fail;
42788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42789 if (SWIG_arg_fail(2)) SWIG_fail;
42790 {
42791 arg3 = &temp3;
42792 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42793 }
42794 {
42795 PyThreadState* __tstate = wxPyBeginAllowThreads();
42796 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42797
42798 wxPyEndAllowThreads(__tstate);
42799 if (PyErr_Occurred()) SWIG_fail;
42800 }
42801 {
42802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42803 }
42804 return resultobj;
42805 fail:
42806 return NULL;
42807 }
42808
42809
42810 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42811 PyObject *resultobj;
42812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42813 wxSizer *arg2 = (wxSizer *) 0 ;
42814 wxGBPosition *arg3 = 0 ;
42815 bool result;
42816 wxGBPosition temp3 ;
42817 PyObject * obj0 = 0 ;
42818 PyObject * obj1 = 0 ;
42819 PyObject * obj2 = 0 ;
42820
42821 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42823 if (SWIG_arg_fail(1)) SWIG_fail;
42824 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42825 if (SWIG_arg_fail(2)) SWIG_fail;
42826 {
42827 arg3 = &temp3;
42828 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42829 }
42830 {
42831 PyThreadState* __tstate = wxPyBeginAllowThreads();
42832 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42833
42834 wxPyEndAllowThreads(__tstate);
42835 if (PyErr_Occurred()) SWIG_fail;
42836 }
42837 {
42838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42847 PyObject *resultobj;
42848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42849 size_t arg2 ;
42850 wxGBPosition *arg3 = 0 ;
42851 bool result;
42852 wxGBPosition temp3 ;
42853 PyObject * obj0 = 0 ;
42854 PyObject * obj1 = 0 ;
42855 PyObject * obj2 = 0 ;
42856
42857 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(1)) SWIG_fail;
42860 {
42861 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42862 if (SWIG_arg_fail(2)) SWIG_fail;
42863 }
42864 {
42865 arg3 = &temp3;
42866 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42867 }
42868 {
42869 PyThreadState* __tstate = wxPyBeginAllowThreads();
42870 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42871
42872 wxPyEndAllowThreads(__tstate);
42873 if (PyErr_Occurred()) SWIG_fail;
42874 }
42875 {
42876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42877 }
42878 return resultobj;
42879 fail:
42880 return NULL;
42881 }
42882
42883
42884 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42885 int argc;
42886 PyObject *argv[4];
42887 int ii;
42888
42889 argc = PyObject_Length(args);
42890 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42891 argv[ii] = PyTuple_GetItem(args,ii);
42892 }
42893 if (argc == 3) {
42894 int _v;
42895 {
42896 void *ptr;
42897 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42898 _v = 0;
42899 PyErr_Clear();
42900 } else {
42901 _v = 1;
42902 }
42903 }
42904 if (_v) {
42905 {
42906 void *ptr;
42907 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42908 _v = 0;
42909 PyErr_Clear();
42910 } else {
42911 _v = 1;
42912 }
42913 }
42914 if (_v) {
42915 {
42916 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42917 }
42918 if (_v) {
42919 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42920 }
42921 }
42922 }
42923 }
42924 if (argc == 3) {
42925 int _v;
42926 {
42927 void *ptr;
42928 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42929 _v = 0;
42930 PyErr_Clear();
42931 } else {
42932 _v = 1;
42933 }
42934 }
42935 if (_v) {
42936 {
42937 void *ptr;
42938 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42939 _v = 0;
42940 PyErr_Clear();
42941 } else {
42942 _v = 1;
42943 }
42944 }
42945 if (_v) {
42946 {
42947 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42948 }
42949 if (_v) {
42950 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42951 }
42952 }
42953 }
42954 }
42955 if (argc == 3) {
42956 int _v;
42957 {
42958 void *ptr;
42959 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42960 _v = 0;
42961 PyErr_Clear();
42962 } else {
42963 _v = 1;
42964 }
42965 }
42966 if (_v) {
42967 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42968 if (_v) {
42969 {
42970 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42971 }
42972 if (_v) {
42973 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42974 }
42975 }
42976 }
42977 }
42978
42979 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42980 return NULL;
42981 }
42982
42983
42984 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42985 PyObject *resultobj;
42986 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42987 wxWindow *arg2 = (wxWindow *) 0 ;
42988 wxGBSpan result;
42989 PyObject * obj0 = 0 ;
42990 PyObject * obj1 = 0 ;
42991
42992 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42994 if (SWIG_arg_fail(1)) SWIG_fail;
42995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42996 if (SWIG_arg_fail(2)) SWIG_fail;
42997 {
42998 PyThreadState* __tstate = wxPyBeginAllowThreads();
42999 result = (arg1)->GetItemSpan(arg2);
43000
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 {
43005 wxGBSpan * resultptr;
43006 resultptr = new wxGBSpan((wxGBSpan &)(result));
43007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43008 }
43009 return resultobj;
43010 fail:
43011 return NULL;
43012 }
43013
43014
43015 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43016 PyObject *resultobj;
43017 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43018 wxSizer *arg2 = (wxSizer *) 0 ;
43019 wxGBSpan result;
43020 PyObject * obj0 = 0 ;
43021 PyObject * obj1 = 0 ;
43022
43023 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43025 if (SWIG_arg_fail(1)) SWIG_fail;
43026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43027 if (SWIG_arg_fail(2)) SWIG_fail;
43028 {
43029 PyThreadState* __tstate = wxPyBeginAllowThreads();
43030 result = (arg1)->GetItemSpan(arg2);
43031
43032 wxPyEndAllowThreads(__tstate);
43033 if (PyErr_Occurred()) SWIG_fail;
43034 }
43035 {
43036 wxGBSpan * resultptr;
43037 resultptr = new wxGBSpan((wxGBSpan &)(result));
43038 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43039 }
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43047 PyObject *resultobj;
43048 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43049 size_t arg2 ;
43050 wxGBSpan result;
43051 PyObject * obj0 = 0 ;
43052 PyObject * obj1 = 0 ;
43053
43054 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43056 if (SWIG_arg_fail(1)) SWIG_fail;
43057 {
43058 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43059 if (SWIG_arg_fail(2)) SWIG_fail;
43060 }
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 result = (arg1)->GetItemSpan(arg2);
43064
43065 wxPyEndAllowThreads(__tstate);
43066 if (PyErr_Occurred()) SWIG_fail;
43067 }
43068 {
43069 wxGBSpan * resultptr;
43070 resultptr = new wxGBSpan((wxGBSpan &)(result));
43071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43072 }
43073 return resultobj;
43074 fail:
43075 return NULL;
43076 }
43077
43078
43079 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43080 int argc;
43081 PyObject *argv[3];
43082 int ii;
43083
43084 argc = PyObject_Length(args);
43085 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43086 argv[ii] = PyTuple_GetItem(args,ii);
43087 }
43088 if (argc == 2) {
43089 int _v;
43090 {
43091 void *ptr;
43092 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43093 _v = 0;
43094 PyErr_Clear();
43095 } else {
43096 _v = 1;
43097 }
43098 }
43099 if (_v) {
43100 {
43101 void *ptr;
43102 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43103 _v = 0;
43104 PyErr_Clear();
43105 } else {
43106 _v = 1;
43107 }
43108 }
43109 if (_v) {
43110 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43111 }
43112 }
43113 }
43114 if (argc == 2) {
43115 int _v;
43116 {
43117 void *ptr;
43118 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43119 _v = 0;
43120 PyErr_Clear();
43121 } else {
43122 _v = 1;
43123 }
43124 }
43125 if (_v) {
43126 {
43127 void *ptr;
43128 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43129 _v = 0;
43130 PyErr_Clear();
43131 } else {
43132 _v = 1;
43133 }
43134 }
43135 if (_v) {
43136 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43137 }
43138 }
43139 }
43140 if (argc == 2) {
43141 int _v;
43142 {
43143 void *ptr;
43144 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43145 _v = 0;
43146 PyErr_Clear();
43147 } else {
43148 _v = 1;
43149 }
43150 }
43151 if (_v) {
43152 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43153 if (_v) {
43154 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43155 }
43156 }
43157 }
43158
43159 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43160 return NULL;
43161 }
43162
43163
43164 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43165 PyObject *resultobj;
43166 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43167 wxWindow *arg2 = (wxWindow *) 0 ;
43168 wxGBSpan *arg3 = 0 ;
43169 bool result;
43170 wxGBSpan temp3 ;
43171 PyObject * obj0 = 0 ;
43172 PyObject * obj1 = 0 ;
43173 PyObject * obj2 = 0 ;
43174
43175 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43177 if (SWIG_arg_fail(1)) SWIG_fail;
43178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43179 if (SWIG_arg_fail(2)) SWIG_fail;
43180 {
43181 arg3 = &temp3;
43182 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43183 }
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43187
43188 wxPyEndAllowThreads(__tstate);
43189 if (PyErr_Occurred()) SWIG_fail;
43190 }
43191 {
43192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43193 }
43194 return resultobj;
43195 fail:
43196 return NULL;
43197 }
43198
43199
43200 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43201 PyObject *resultobj;
43202 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43203 wxSizer *arg2 = (wxSizer *) 0 ;
43204 wxGBSpan *arg3 = 0 ;
43205 bool result;
43206 wxGBSpan temp3 ;
43207 PyObject * obj0 = 0 ;
43208 PyObject * obj1 = 0 ;
43209 PyObject * obj2 = 0 ;
43210
43211 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43213 if (SWIG_arg_fail(1)) SWIG_fail;
43214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43215 if (SWIG_arg_fail(2)) SWIG_fail;
43216 {
43217 arg3 = &temp3;
43218 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43219 }
43220 {
43221 PyThreadState* __tstate = wxPyBeginAllowThreads();
43222 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43223
43224 wxPyEndAllowThreads(__tstate);
43225 if (PyErr_Occurred()) SWIG_fail;
43226 }
43227 {
43228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43229 }
43230 return resultobj;
43231 fail:
43232 return NULL;
43233 }
43234
43235
43236 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43237 PyObject *resultobj;
43238 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43239 size_t arg2 ;
43240 wxGBSpan *arg3 = 0 ;
43241 bool result;
43242 wxGBSpan temp3 ;
43243 PyObject * obj0 = 0 ;
43244 PyObject * obj1 = 0 ;
43245 PyObject * obj2 = 0 ;
43246
43247 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43249 if (SWIG_arg_fail(1)) SWIG_fail;
43250 {
43251 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43252 if (SWIG_arg_fail(2)) SWIG_fail;
43253 }
43254 {
43255 arg3 = &temp3;
43256 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43257 }
43258 {
43259 PyThreadState* __tstate = wxPyBeginAllowThreads();
43260 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43261
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43267 }
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43275 int argc;
43276 PyObject *argv[4];
43277 int ii;
43278
43279 argc = PyObject_Length(args);
43280 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43281 argv[ii] = PyTuple_GetItem(args,ii);
43282 }
43283 if (argc == 3) {
43284 int _v;
43285 {
43286 void *ptr;
43287 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43288 _v = 0;
43289 PyErr_Clear();
43290 } else {
43291 _v = 1;
43292 }
43293 }
43294 if (_v) {
43295 {
43296 void *ptr;
43297 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43298 _v = 0;
43299 PyErr_Clear();
43300 } else {
43301 _v = 1;
43302 }
43303 }
43304 if (_v) {
43305 {
43306 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43307 }
43308 if (_v) {
43309 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43310 }
43311 }
43312 }
43313 }
43314 if (argc == 3) {
43315 int _v;
43316 {
43317 void *ptr;
43318 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43319 _v = 0;
43320 PyErr_Clear();
43321 } else {
43322 _v = 1;
43323 }
43324 }
43325 if (_v) {
43326 {
43327 void *ptr;
43328 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43329 _v = 0;
43330 PyErr_Clear();
43331 } else {
43332 _v = 1;
43333 }
43334 }
43335 if (_v) {
43336 {
43337 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43338 }
43339 if (_v) {
43340 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43341 }
43342 }
43343 }
43344 }
43345 if (argc == 3) {
43346 int _v;
43347 {
43348 void *ptr;
43349 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43350 _v = 0;
43351 PyErr_Clear();
43352 } else {
43353 _v = 1;
43354 }
43355 }
43356 if (_v) {
43357 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43358 if (_v) {
43359 {
43360 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43361 }
43362 if (_v) {
43363 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43364 }
43365 }
43366 }
43367 }
43368
43369 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43370 return NULL;
43371 }
43372
43373
43374 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43375 PyObject *resultobj;
43376 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43377 wxWindow *arg2 = (wxWindow *) 0 ;
43378 wxGBSizerItem *result;
43379 PyObject * obj0 = 0 ;
43380 PyObject * obj1 = 0 ;
43381
43382 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43384 if (SWIG_arg_fail(1)) SWIG_fail;
43385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43386 if (SWIG_arg_fail(2)) SWIG_fail;
43387 {
43388 PyThreadState* __tstate = wxPyBeginAllowThreads();
43389 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43390
43391 wxPyEndAllowThreads(__tstate);
43392 if (PyErr_Occurred()) SWIG_fail;
43393 }
43394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43395 return resultobj;
43396 fail:
43397 return NULL;
43398 }
43399
43400
43401 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43402 PyObject *resultobj;
43403 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43404 wxSizer *arg2 = (wxSizer *) 0 ;
43405 wxGBSizerItem *result;
43406 PyObject * obj0 = 0 ;
43407 PyObject * obj1 = 0 ;
43408
43409 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43411 if (SWIG_arg_fail(1)) SWIG_fail;
43412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43413 if (SWIG_arg_fail(2)) SWIG_fail;
43414 {
43415 PyThreadState* __tstate = wxPyBeginAllowThreads();
43416 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43417
43418 wxPyEndAllowThreads(__tstate);
43419 if (PyErr_Occurred()) SWIG_fail;
43420 }
43421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43422 return resultobj;
43423 fail:
43424 return NULL;
43425 }
43426
43427
43428 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43429 int argc;
43430 PyObject *argv[3];
43431 int ii;
43432
43433 argc = PyObject_Length(args);
43434 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43435 argv[ii] = PyTuple_GetItem(args,ii);
43436 }
43437 if (argc == 2) {
43438 int _v;
43439 {
43440 void *ptr;
43441 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43442 _v = 0;
43443 PyErr_Clear();
43444 } else {
43445 _v = 1;
43446 }
43447 }
43448 if (_v) {
43449 {
43450 void *ptr;
43451 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43452 _v = 0;
43453 PyErr_Clear();
43454 } else {
43455 _v = 1;
43456 }
43457 }
43458 if (_v) {
43459 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43460 }
43461 }
43462 }
43463 if (argc == 2) {
43464 int _v;
43465 {
43466 void *ptr;
43467 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43468 _v = 0;
43469 PyErr_Clear();
43470 } else {
43471 _v = 1;
43472 }
43473 }
43474 if (_v) {
43475 {
43476 void *ptr;
43477 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43478 _v = 0;
43479 PyErr_Clear();
43480 } else {
43481 _v = 1;
43482 }
43483 }
43484 if (_v) {
43485 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43486 }
43487 }
43488 }
43489
43490 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43491 return NULL;
43492 }
43493
43494
43495 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43496 PyObject *resultobj;
43497 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43498 wxGBPosition *arg2 = 0 ;
43499 wxGBSizerItem *result;
43500 wxGBPosition temp2 ;
43501 PyObject * obj0 = 0 ;
43502 PyObject * obj1 = 0 ;
43503 char *kwnames[] = {
43504 (char *) "self",(char *) "pos", NULL
43505 };
43506
43507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43509 if (SWIG_arg_fail(1)) SWIG_fail;
43510 {
43511 arg2 = &temp2;
43512 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43513 }
43514 {
43515 PyThreadState* __tstate = wxPyBeginAllowThreads();
43516 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43517
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43522 return resultobj;
43523 fail:
43524 return NULL;
43525 }
43526
43527
43528 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43529 PyObject *resultobj;
43530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43531 wxPoint *arg2 = 0 ;
43532 wxGBSizerItem *result;
43533 wxPoint temp2 ;
43534 PyObject * obj0 = 0 ;
43535 PyObject * obj1 = 0 ;
43536 char *kwnames[] = {
43537 (char *) "self",(char *) "pt", NULL
43538 };
43539
43540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43542 if (SWIG_arg_fail(1)) SWIG_fail;
43543 {
43544 arg2 = &temp2;
43545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43546 }
43547 {
43548 PyThreadState* __tstate = wxPyBeginAllowThreads();
43549 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43550
43551 wxPyEndAllowThreads(__tstate);
43552 if (PyErr_Occurred()) SWIG_fail;
43553 }
43554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43555 return resultobj;
43556 fail:
43557 return NULL;
43558 }
43559
43560
43561 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43562 PyObject *resultobj;
43563 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43564 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43565 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43566 bool result;
43567 PyObject * obj0 = 0 ;
43568 PyObject * obj1 = 0 ;
43569 PyObject * obj2 = 0 ;
43570 char *kwnames[] = {
43571 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43572 };
43573
43574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43576 if (SWIG_arg_fail(1)) SWIG_fail;
43577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43578 if (SWIG_arg_fail(2)) SWIG_fail;
43579 if (obj2) {
43580 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43581 if (SWIG_arg_fail(3)) SWIG_fail;
43582 }
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43586
43587 wxPyEndAllowThreads(__tstate);
43588 if (PyErr_Occurred()) SWIG_fail;
43589 }
43590 {
43591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43592 }
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43600 PyObject *resultobj;
43601 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43602 wxGBPosition *arg2 = 0 ;
43603 wxGBSpan *arg3 = 0 ;
43604 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43605 bool result;
43606 wxGBPosition temp2 ;
43607 wxGBSpan temp3 ;
43608 PyObject * obj0 = 0 ;
43609 PyObject * obj1 = 0 ;
43610 PyObject * obj2 = 0 ;
43611 PyObject * obj3 = 0 ;
43612 char *kwnames[] = {
43613 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43614 };
43615
43616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43618 if (SWIG_arg_fail(1)) SWIG_fail;
43619 {
43620 arg2 = &temp2;
43621 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43622 }
43623 {
43624 arg3 = &temp3;
43625 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43626 }
43627 if (obj3) {
43628 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43629 if (SWIG_arg_fail(4)) SWIG_fail;
43630 }
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43634
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 {
43639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43640 }
43641 return resultobj;
43642 fail:
43643 return NULL;
43644 }
43645
43646
43647 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43648 PyObject *obj;
43649 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43650 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43651 Py_INCREF(obj);
43652 return Py_BuildValue((char *)"");
43653 }
43654 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43655 PyObject *resultobj;
43656 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43657 wxRelationship arg2 ;
43658 wxWindow *arg3 = (wxWindow *) 0 ;
43659 wxEdge arg4 ;
43660 int arg5 = (int) 0 ;
43661 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43662 PyObject * obj0 = 0 ;
43663 PyObject * obj1 = 0 ;
43664 PyObject * obj2 = 0 ;
43665 PyObject * obj3 = 0 ;
43666 PyObject * obj4 = 0 ;
43667 PyObject * obj5 = 0 ;
43668 char *kwnames[] = {
43669 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43670 };
43671
43672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43674 if (SWIG_arg_fail(1)) SWIG_fail;
43675 {
43676 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43677 if (SWIG_arg_fail(2)) SWIG_fail;
43678 }
43679 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43680 if (SWIG_arg_fail(3)) SWIG_fail;
43681 {
43682 arg4 = (wxEdge)(SWIG_As_int(obj3));
43683 if (SWIG_arg_fail(4)) SWIG_fail;
43684 }
43685 if (obj4) {
43686 {
43687 arg5 = (int)(SWIG_As_int(obj4));
43688 if (SWIG_arg_fail(5)) SWIG_fail;
43689 }
43690 }
43691 if (obj5) {
43692 {
43693 arg6 = (int)(SWIG_As_int(obj5));
43694 if (SWIG_arg_fail(6)) SWIG_fail;
43695 }
43696 }
43697 {
43698 PyThreadState* __tstate = wxPyBeginAllowThreads();
43699 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43700
43701 wxPyEndAllowThreads(__tstate);
43702 if (PyErr_Occurred()) SWIG_fail;
43703 }
43704 Py_INCREF(Py_None); resultobj = Py_None;
43705 return resultobj;
43706 fail:
43707 return NULL;
43708 }
43709
43710
43711 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43712 PyObject *resultobj;
43713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43714 wxWindow *arg2 = (wxWindow *) 0 ;
43715 int arg3 = (int) 0 ;
43716 PyObject * obj0 = 0 ;
43717 PyObject * obj1 = 0 ;
43718 PyObject * obj2 = 0 ;
43719 char *kwnames[] = {
43720 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43721 };
43722
43723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43725 if (SWIG_arg_fail(1)) SWIG_fail;
43726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43727 if (SWIG_arg_fail(2)) SWIG_fail;
43728 if (obj2) {
43729 {
43730 arg3 = (int)(SWIG_As_int(obj2));
43731 if (SWIG_arg_fail(3)) SWIG_fail;
43732 }
43733 }
43734 {
43735 PyThreadState* __tstate = wxPyBeginAllowThreads();
43736 (arg1)->LeftOf(arg2,arg3);
43737
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 Py_INCREF(Py_None); resultobj = Py_None;
43742 return resultobj;
43743 fail:
43744 return NULL;
43745 }
43746
43747
43748 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43749 PyObject *resultobj;
43750 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43751 wxWindow *arg2 = (wxWindow *) 0 ;
43752 int arg3 = (int) 0 ;
43753 PyObject * obj0 = 0 ;
43754 PyObject * obj1 = 0 ;
43755 PyObject * obj2 = 0 ;
43756 char *kwnames[] = {
43757 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43758 };
43759
43760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43762 if (SWIG_arg_fail(1)) SWIG_fail;
43763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43764 if (SWIG_arg_fail(2)) SWIG_fail;
43765 if (obj2) {
43766 {
43767 arg3 = (int)(SWIG_As_int(obj2));
43768 if (SWIG_arg_fail(3)) SWIG_fail;
43769 }
43770 }
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 (arg1)->RightOf(arg2,arg3);
43774
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 Py_INCREF(Py_None); resultobj = Py_None;
43779 return resultobj;
43780 fail:
43781 return NULL;
43782 }
43783
43784
43785 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43786 PyObject *resultobj;
43787 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43788 wxWindow *arg2 = (wxWindow *) 0 ;
43789 int arg3 = (int) 0 ;
43790 PyObject * obj0 = 0 ;
43791 PyObject * obj1 = 0 ;
43792 PyObject * obj2 = 0 ;
43793 char *kwnames[] = {
43794 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43795 };
43796
43797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43799 if (SWIG_arg_fail(1)) SWIG_fail;
43800 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43801 if (SWIG_arg_fail(2)) SWIG_fail;
43802 if (obj2) {
43803 {
43804 arg3 = (int)(SWIG_As_int(obj2));
43805 if (SWIG_arg_fail(3)) SWIG_fail;
43806 }
43807 }
43808 {
43809 PyThreadState* __tstate = wxPyBeginAllowThreads();
43810 (arg1)->Above(arg2,arg3);
43811
43812 wxPyEndAllowThreads(__tstate);
43813 if (PyErr_Occurred()) SWIG_fail;
43814 }
43815 Py_INCREF(Py_None); resultobj = Py_None;
43816 return resultobj;
43817 fail:
43818 return NULL;
43819 }
43820
43821
43822 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43823 PyObject *resultobj;
43824 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43825 wxWindow *arg2 = (wxWindow *) 0 ;
43826 int arg3 = (int) 0 ;
43827 PyObject * obj0 = 0 ;
43828 PyObject * obj1 = 0 ;
43829 PyObject * obj2 = 0 ;
43830 char *kwnames[] = {
43831 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43832 };
43833
43834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43836 if (SWIG_arg_fail(1)) SWIG_fail;
43837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43838 if (SWIG_arg_fail(2)) SWIG_fail;
43839 if (obj2) {
43840 {
43841 arg3 = (int)(SWIG_As_int(obj2));
43842 if (SWIG_arg_fail(3)) SWIG_fail;
43843 }
43844 }
43845 {
43846 PyThreadState* __tstate = wxPyBeginAllowThreads();
43847 (arg1)->Below(arg2,arg3);
43848
43849 wxPyEndAllowThreads(__tstate);
43850 if (PyErr_Occurred()) SWIG_fail;
43851 }
43852 Py_INCREF(Py_None); resultobj = Py_None;
43853 return resultobj;
43854 fail:
43855 return NULL;
43856 }
43857
43858
43859 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43860 PyObject *resultobj;
43861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43862 wxWindow *arg2 = (wxWindow *) 0 ;
43863 wxEdge arg3 ;
43864 int arg4 = (int) 0 ;
43865 PyObject * obj0 = 0 ;
43866 PyObject * obj1 = 0 ;
43867 PyObject * obj2 = 0 ;
43868 PyObject * obj3 = 0 ;
43869 char *kwnames[] = {
43870 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43871 };
43872
43873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43875 if (SWIG_arg_fail(1)) SWIG_fail;
43876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43877 if (SWIG_arg_fail(2)) SWIG_fail;
43878 {
43879 arg3 = (wxEdge)(SWIG_As_int(obj2));
43880 if (SWIG_arg_fail(3)) SWIG_fail;
43881 }
43882 if (obj3) {
43883 {
43884 arg4 = (int)(SWIG_As_int(obj3));
43885 if (SWIG_arg_fail(4)) SWIG_fail;
43886 }
43887 }
43888 {
43889 PyThreadState* __tstate = wxPyBeginAllowThreads();
43890 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43891
43892 wxPyEndAllowThreads(__tstate);
43893 if (PyErr_Occurred()) SWIG_fail;
43894 }
43895 Py_INCREF(Py_None); resultobj = Py_None;
43896 return resultobj;
43897 fail:
43898 return NULL;
43899 }
43900
43901
43902 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43903 PyObject *resultobj;
43904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43905 wxWindow *arg2 = (wxWindow *) 0 ;
43906 wxEdge arg3 ;
43907 int arg4 ;
43908 PyObject * obj0 = 0 ;
43909 PyObject * obj1 = 0 ;
43910 PyObject * obj2 = 0 ;
43911 PyObject * obj3 = 0 ;
43912 char *kwnames[] = {
43913 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43914 };
43915
43916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43918 if (SWIG_arg_fail(1)) SWIG_fail;
43919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43920 if (SWIG_arg_fail(2)) SWIG_fail;
43921 {
43922 arg3 = (wxEdge)(SWIG_As_int(obj2));
43923 if (SWIG_arg_fail(3)) SWIG_fail;
43924 }
43925 {
43926 arg4 = (int)(SWIG_As_int(obj3));
43927 if (SWIG_arg_fail(4)) SWIG_fail;
43928 }
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43932
43933 wxPyEndAllowThreads(__tstate);
43934 if (PyErr_Occurred()) SWIG_fail;
43935 }
43936 Py_INCREF(Py_None); resultobj = Py_None;
43937 return resultobj;
43938 fail:
43939 return NULL;
43940 }
43941
43942
43943 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43944 PyObject *resultobj;
43945 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43946 int arg2 ;
43947 PyObject * obj0 = 0 ;
43948 PyObject * obj1 = 0 ;
43949 char *kwnames[] = {
43950 (char *) "self",(char *) "val", NULL
43951 };
43952
43953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43955 if (SWIG_arg_fail(1)) SWIG_fail;
43956 {
43957 arg2 = (int)(SWIG_As_int(obj1));
43958 if (SWIG_arg_fail(2)) SWIG_fail;
43959 }
43960 {
43961 PyThreadState* __tstate = wxPyBeginAllowThreads();
43962 (arg1)->Absolute(arg2);
43963
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 Py_INCREF(Py_None); resultobj = Py_None;
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj;
43976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43977 PyObject * obj0 = 0 ;
43978 char *kwnames[] = {
43979 (char *) "self", NULL
43980 };
43981
43982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43984 if (SWIG_arg_fail(1)) SWIG_fail;
43985 {
43986 PyThreadState* __tstate = wxPyBeginAllowThreads();
43987 (arg1)->Unconstrained();
43988
43989 wxPyEndAllowThreads(__tstate);
43990 if (PyErr_Occurred()) SWIG_fail;
43991 }
43992 Py_INCREF(Py_None); resultobj = Py_None;
43993 return resultobj;
43994 fail:
43995 return NULL;
43996 }
43997
43998
43999 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44000 PyObject *resultobj;
44001 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44002 PyObject * obj0 = 0 ;
44003 char *kwnames[] = {
44004 (char *) "self", NULL
44005 };
44006
44007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44009 if (SWIG_arg_fail(1)) SWIG_fail;
44010 {
44011 PyThreadState* __tstate = wxPyBeginAllowThreads();
44012 (arg1)->AsIs();
44013
44014 wxPyEndAllowThreads(__tstate);
44015 if (PyErr_Occurred()) SWIG_fail;
44016 }
44017 Py_INCREF(Py_None); resultobj = Py_None;
44018 return resultobj;
44019 fail:
44020 return NULL;
44021 }
44022
44023
44024 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44025 PyObject *resultobj;
44026 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44027 wxWindow *result;
44028 PyObject * obj0 = 0 ;
44029 char *kwnames[] = {
44030 (char *) "self", NULL
44031 };
44032
44033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44035 if (SWIG_arg_fail(1)) SWIG_fail;
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = (wxWindow *)(arg1)->GetOtherWindow();
44039
44040 wxPyEndAllowThreads(__tstate);
44041 if (PyErr_Occurred()) SWIG_fail;
44042 }
44043 {
44044 resultobj = wxPyMake_wxObject(result, 0);
44045 }
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj;
44054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44055 wxEdge result;
44056 PyObject * obj0 = 0 ;
44057 char *kwnames[] = {
44058 (char *) "self", NULL
44059 };
44060
44061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44063 if (SWIG_arg_fail(1)) SWIG_fail;
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44067
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 resultobj = SWIG_From_int((result));
44072 return resultobj;
44073 fail:
44074 return NULL;
44075 }
44076
44077
44078 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44079 PyObject *resultobj;
44080 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44081 wxEdge arg2 ;
44082 PyObject * obj0 = 0 ;
44083 PyObject * obj1 = 0 ;
44084 char *kwnames[] = {
44085 (char *) "self",(char *) "which", NULL
44086 };
44087
44088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44090 if (SWIG_arg_fail(1)) SWIG_fail;
44091 {
44092 arg2 = (wxEdge)(SWIG_As_int(obj1));
44093 if (SWIG_arg_fail(2)) SWIG_fail;
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 (arg1)->SetEdge((wxEdge )arg2);
44098
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 Py_INCREF(Py_None); resultobj = Py_None;
44103 return resultobj;
44104 fail:
44105 return NULL;
44106 }
44107
44108
44109 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44110 PyObject *resultobj;
44111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44112 int arg2 ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 char *kwnames[] = {
44116 (char *) "self",(char *) "v", NULL
44117 };
44118
44119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44121 if (SWIG_arg_fail(1)) SWIG_fail;
44122 {
44123 arg2 = (int)(SWIG_As_int(obj1));
44124 if (SWIG_arg_fail(2)) SWIG_fail;
44125 }
44126 {
44127 PyThreadState* __tstate = wxPyBeginAllowThreads();
44128 (arg1)->SetValue(arg2);
44129
44130 wxPyEndAllowThreads(__tstate);
44131 if (PyErr_Occurred()) SWIG_fail;
44132 }
44133 Py_INCREF(Py_None); resultobj = Py_None;
44134 return resultobj;
44135 fail:
44136 return NULL;
44137 }
44138
44139
44140 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44141 PyObject *resultobj;
44142 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44143 int result;
44144 PyObject * obj0 = 0 ;
44145 char *kwnames[] = {
44146 (char *) "self", NULL
44147 };
44148
44149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44151 if (SWIG_arg_fail(1)) SWIG_fail;
44152 {
44153 PyThreadState* __tstate = wxPyBeginAllowThreads();
44154 result = (int)(arg1)->GetMargin();
44155
44156 wxPyEndAllowThreads(__tstate);
44157 if (PyErr_Occurred()) SWIG_fail;
44158 }
44159 {
44160 resultobj = SWIG_From_int((int)(result));
44161 }
44162 return resultobj;
44163 fail:
44164 return NULL;
44165 }
44166
44167
44168 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44169 PyObject *resultobj;
44170 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44171 int arg2 ;
44172 PyObject * obj0 = 0 ;
44173 PyObject * obj1 = 0 ;
44174 char *kwnames[] = {
44175 (char *) "self",(char *) "m", NULL
44176 };
44177
44178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44180 if (SWIG_arg_fail(1)) SWIG_fail;
44181 {
44182 arg2 = (int)(SWIG_As_int(obj1));
44183 if (SWIG_arg_fail(2)) SWIG_fail;
44184 }
44185 {
44186 PyThreadState* __tstate = wxPyBeginAllowThreads();
44187 (arg1)->SetMargin(arg2);
44188
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 Py_INCREF(Py_None); resultobj = Py_None;
44193 return resultobj;
44194 fail:
44195 return NULL;
44196 }
44197
44198
44199 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44200 PyObject *resultobj;
44201 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44202 int result;
44203 PyObject * obj0 = 0 ;
44204 char *kwnames[] = {
44205 (char *) "self", NULL
44206 };
44207
44208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44210 if (SWIG_arg_fail(1)) SWIG_fail;
44211 {
44212 PyThreadState* __tstate = wxPyBeginAllowThreads();
44213 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44214
44215 wxPyEndAllowThreads(__tstate);
44216 if (PyErr_Occurred()) SWIG_fail;
44217 }
44218 {
44219 resultobj = SWIG_From_int((int)(result));
44220 }
44221 return resultobj;
44222 fail:
44223 return NULL;
44224 }
44225
44226
44227 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj;
44229 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44230 int result;
44231 PyObject * obj0 = 0 ;
44232 char *kwnames[] = {
44233 (char *) "self", NULL
44234 };
44235
44236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44238 if (SWIG_arg_fail(1)) SWIG_fail;
44239 {
44240 PyThreadState* __tstate = wxPyBeginAllowThreads();
44241 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44242
44243 wxPyEndAllowThreads(__tstate);
44244 if (PyErr_Occurred()) SWIG_fail;
44245 }
44246 {
44247 resultobj = SWIG_From_int((int)(result));
44248 }
44249 return resultobj;
44250 fail:
44251 return NULL;
44252 }
44253
44254
44255 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44256 PyObject *resultobj;
44257 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44258 int result;
44259 PyObject * obj0 = 0 ;
44260 char *kwnames[] = {
44261 (char *) "self", NULL
44262 };
44263
44264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44266 if (SWIG_arg_fail(1)) SWIG_fail;
44267 {
44268 PyThreadState* __tstate = wxPyBeginAllowThreads();
44269 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44270
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 {
44275 resultobj = SWIG_From_int((int)(result));
44276 }
44277 return resultobj;
44278 fail:
44279 return NULL;
44280 }
44281
44282
44283 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44284 PyObject *resultobj;
44285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44286 bool result;
44287 PyObject * obj0 = 0 ;
44288 char *kwnames[] = {
44289 (char *) "self", NULL
44290 };
44291
44292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44294 if (SWIG_arg_fail(1)) SWIG_fail;
44295 {
44296 PyThreadState* __tstate = wxPyBeginAllowThreads();
44297 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44298
44299 wxPyEndAllowThreads(__tstate);
44300 if (PyErr_Occurred()) SWIG_fail;
44301 }
44302 {
44303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44304 }
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44312 PyObject *resultobj;
44313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44314 bool arg2 ;
44315 PyObject * obj0 = 0 ;
44316 PyObject * obj1 = 0 ;
44317 char *kwnames[] = {
44318 (char *) "self",(char *) "d", NULL
44319 };
44320
44321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44323 if (SWIG_arg_fail(1)) SWIG_fail;
44324 {
44325 arg2 = (bool)(SWIG_As_bool(obj1));
44326 if (SWIG_arg_fail(2)) SWIG_fail;
44327 }
44328 {
44329 PyThreadState* __tstate = wxPyBeginAllowThreads();
44330 (arg1)->SetDone(arg2);
44331
44332 wxPyEndAllowThreads(__tstate);
44333 if (PyErr_Occurred()) SWIG_fail;
44334 }
44335 Py_INCREF(Py_None); resultobj = Py_None;
44336 return resultobj;
44337 fail:
44338 return NULL;
44339 }
44340
44341
44342 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44343 PyObject *resultobj;
44344 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44345 wxRelationship result;
44346 PyObject * obj0 = 0 ;
44347 char *kwnames[] = {
44348 (char *) "self", NULL
44349 };
44350
44351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44353 if (SWIG_arg_fail(1)) SWIG_fail;
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 result = (wxRelationship)(arg1)->GetRelationship();
44357
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_From_int((result));
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44369 PyObject *resultobj;
44370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44371 wxRelationship arg2 ;
44372 PyObject * obj0 = 0 ;
44373 PyObject * obj1 = 0 ;
44374 char *kwnames[] = {
44375 (char *) "self",(char *) "r", NULL
44376 };
44377
44378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44380 if (SWIG_arg_fail(1)) SWIG_fail;
44381 {
44382 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44383 if (SWIG_arg_fail(2)) SWIG_fail;
44384 }
44385 {
44386 PyThreadState* __tstate = wxPyBeginAllowThreads();
44387 (arg1)->SetRelationship((wxRelationship )arg2);
44388
44389 wxPyEndAllowThreads(__tstate);
44390 if (PyErr_Occurred()) SWIG_fail;
44391 }
44392 Py_INCREF(Py_None); resultobj = Py_None;
44393 return resultobj;
44394 fail:
44395 return NULL;
44396 }
44397
44398
44399 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44400 PyObject *resultobj;
44401 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44402 wxWindow *arg2 = (wxWindow *) 0 ;
44403 bool result;
44404 PyObject * obj0 = 0 ;
44405 PyObject * obj1 = 0 ;
44406 char *kwnames[] = {
44407 (char *) "self",(char *) "otherW", NULL
44408 };
44409
44410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44412 if (SWIG_arg_fail(1)) SWIG_fail;
44413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44414 if (SWIG_arg_fail(2)) SWIG_fail;
44415 {
44416 PyThreadState* __tstate = wxPyBeginAllowThreads();
44417 result = (bool)(arg1)->ResetIfWin(arg2);
44418
44419 wxPyEndAllowThreads(__tstate);
44420 if (PyErr_Occurred()) SWIG_fail;
44421 }
44422 {
44423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44424 }
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44432 PyObject *resultobj;
44433 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44434 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44435 wxWindow *arg3 = (wxWindow *) 0 ;
44436 bool result;
44437 PyObject * obj0 = 0 ;
44438 PyObject * obj1 = 0 ;
44439 PyObject * obj2 = 0 ;
44440 char *kwnames[] = {
44441 (char *) "self",(char *) "constraints",(char *) "win", NULL
44442 };
44443
44444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44446 if (SWIG_arg_fail(1)) SWIG_fail;
44447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44448 if (SWIG_arg_fail(2)) SWIG_fail;
44449 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44450 if (SWIG_arg_fail(3)) SWIG_fail;
44451 {
44452 PyThreadState* __tstate = wxPyBeginAllowThreads();
44453 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44454
44455 wxPyEndAllowThreads(__tstate);
44456 if (PyErr_Occurred()) SWIG_fail;
44457 }
44458 {
44459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44460 }
44461 return resultobj;
44462 fail:
44463 return NULL;
44464 }
44465
44466
44467 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44468 PyObject *resultobj;
44469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44470 wxEdge arg2 ;
44471 wxWindow *arg3 = (wxWindow *) 0 ;
44472 wxWindow *arg4 = (wxWindow *) 0 ;
44473 int result;
44474 PyObject * obj0 = 0 ;
44475 PyObject * obj1 = 0 ;
44476 PyObject * obj2 = 0 ;
44477 PyObject * obj3 = 0 ;
44478 char *kwnames[] = {
44479 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44480 };
44481
44482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44484 if (SWIG_arg_fail(1)) SWIG_fail;
44485 {
44486 arg2 = (wxEdge)(SWIG_As_int(obj1));
44487 if (SWIG_arg_fail(2)) SWIG_fail;
44488 }
44489 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44490 if (SWIG_arg_fail(3)) SWIG_fail;
44491 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44492 if (SWIG_arg_fail(4)) SWIG_fail;
44493 {
44494 PyThreadState* __tstate = wxPyBeginAllowThreads();
44495 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44496
44497 wxPyEndAllowThreads(__tstate);
44498 if (PyErr_Occurred()) SWIG_fail;
44499 }
44500 {
44501 resultobj = SWIG_From_int((int)(result));
44502 }
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44510 PyObject *obj;
44511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44512 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44513 Py_INCREF(obj);
44514 return Py_BuildValue((char *)"");
44515 }
44516 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj;
44518 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44519 wxIndividualLayoutConstraint *result;
44520 PyObject * obj0 = 0 ;
44521 char *kwnames[] = {
44522 (char *) "self", NULL
44523 };
44524
44525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44527 if (SWIG_arg_fail(1)) SWIG_fail;
44528 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44529
44530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44538 PyObject *resultobj;
44539 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44540 wxIndividualLayoutConstraint *result;
44541 PyObject * obj0 = 0 ;
44542 char *kwnames[] = {
44543 (char *) "self", NULL
44544 };
44545
44546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44548 if (SWIG_arg_fail(1)) SWIG_fail;
44549 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44550
44551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44552 return resultobj;
44553 fail:
44554 return NULL;
44555 }
44556
44557
44558 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44559 PyObject *resultobj;
44560 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44561 wxIndividualLayoutConstraint *result;
44562 PyObject * obj0 = 0 ;
44563 char *kwnames[] = {
44564 (char *) "self", NULL
44565 };
44566
44567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44569 if (SWIG_arg_fail(1)) SWIG_fail;
44570 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44571
44572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44580 PyObject *resultobj;
44581 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44582 wxIndividualLayoutConstraint *result;
44583 PyObject * obj0 = 0 ;
44584 char *kwnames[] = {
44585 (char *) "self", NULL
44586 };
44587
44588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44590 if (SWIG_arg_fail(1)) SWIG_fail;
44591 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44592
44593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44601 PyObject *resultobj;
44602 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44603 wxIndividualLayoutConstraint *result;
44604 PyObject * obj0 = 0 ;
44605 char *kwnames[] = {
44606 (char *) "self", NULL
44607 };
44608
44609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(1)) SWIG_fail;
44612 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44613
44614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj;
44623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44624 wxIndividualLayoutConstraint *result;
44625 PyObject * obj0 = 0 ;
44626 char *kwnames[] = {
44627 (char *) "self", NULL
44628 };
44629
44630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44632 if (SWIG_arg_fail(1)) SWIG_fail;
44633 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44634
44635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj;
44644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44645 wxIndividualLayoutConstraint *result;
44646 PyObject * obj0 = 0 ;
44647 char *kwnames[] = {
44648 (char *) "self", NULL
44649 };
44650
44651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44653 if (SWIG_arg_fail(1)) SWIG_fail;
44654 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44655
44656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44664 PyObject *resultobj;
44665 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44666 wxIndividualLayoutConstraint *result;
44667 PyObject * obj0 = 0 ;
44668 char *kwnames[] = {
44669 (char *) "self", NULL
44670 };
44671
44672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(1)) SWIG_fail;
44675 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44676
44677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44678 return resultobj;
44679 fail:
44680 return NULL;
44681 }
44682
44683
44684 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44685 PyObject *resultobj;
44686 wxLayoutConstraints *result;
44687 char *kwnames[] = {
44688 NULL
44689 };
44690
44691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44692 {
44693 PyThreadState* __tstate = wxPyBeginAllowThreads();
44694 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44695
44696 wxPyEndAllowThreads(__tstate);
44697 if (PyErr_Occurred()) SWIG_fail;
44698 }
44699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44700 return resultobj;
44701 fail:
44702 return NULL;
44703 }
44704
44705
44706 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44707 PyObject *resultobj;
44708 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44709 wxWindow *arg2 = (wxWindow *) 0 ;
44710 int *arg3 = (int *) 0 ;
44711 bool result;
44712 int temp3 ;
44713 int res3 = 0 ;
44714 PyObject * obj0 = 0 ;
44715 PyObject * obj1 = 0 ;
44716 char *kwnames[] = {
44717 (char *) "self",(char *) "win", NULL
44718 };
44719
44720 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44723 if (SWIG_arg_fail(1)) SWIG_fail;
44724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44725 if (SWIG_arg_fail(2)) SWIG_fail;
44726 {
44727 PyThreadState* __tstate = wxPyBeginAllowThreads();
44728 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44729
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 {
44734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44735 }
44736 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44737 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44738 return resultobj;
44739 fail:
44740 return NULL;
44741 }
44742
44743
44744 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44745 PyObject *resultobj;
44746 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44747 bool result;
44748 PyObject * obj0 = 0 ;
44749 char *kwnames[] = {
44750 (char *) "self", NULL
44751 };
44752
44753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44755 if (SWIG_arg_fail(1)) SWIG_fail;
44756 {
44757 PyThreadState* __tstate = wxPyBeginAllowThreads();
44758 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44759
44760 wxPyEndAllowThreads(__tstate);
44761 if (PyErr_Occurred()) SWIG_fail;
44762 }
44763 {
44764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44765 }
44766 return resultobj;
44767 fail:
44768 return NULL;
44769 }
44770
44771
44772 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44773 PyObject *obj;
44774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44775 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44776 Py_INCREF(obj);
44777 return Py_BuildValue((char *)"");
44778 }
44779 static PyMethodDef SwigMethods[] = {
44780 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44781 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44782 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44785 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44806 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44819 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44834 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44887 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44915 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44934 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44936 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44944 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44945 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44957 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44969 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44973 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44979 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44989 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44999 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45003 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45078 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45080 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45082 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45084 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45086 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45088 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45090 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45092 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45094 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45096 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45098 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45100 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45102 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45116 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45134 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45137 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45140 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45152 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45157 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45163 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45169 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45232 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45239 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45275 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45285 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45291 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45293 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45295 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45298 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45302 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45305 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45308 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45310 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45315 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45323 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45327 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45330 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45332 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45336 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45353 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45355 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45358 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45360 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45364 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45368 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45379 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45382 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45385 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45389 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45396 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45401 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45406 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45410 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45455 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45475 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45482 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45486 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45496 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45666 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45708 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45722 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45725 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45780 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45807 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45851 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45859 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45878 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45879 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45916 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45946 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45949 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45953 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45956 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45966 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45978 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45990 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46000 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46010 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46024 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46031 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46032 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46033 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46034 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46035 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46040 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46067 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46079 { NULL, NULL, 0, NULL }
46080 };
46081
46082
46083 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46084
46085 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46086 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46087 }
46088 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46089 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46090 }
46091 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46092 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46093 }
46094 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46095 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46096 }
46097 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46098 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46099 }
46100 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46101 return (void *)((wxSizer *) ((wxGridSizer *) x));
46102 }
46103 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46104 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46105 }
46106 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46107 return (void *)((wxSizer *) ((wxPySizer *) x));
46108 }
46109 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46110 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46111 }
46112 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46113 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46114 }
46115 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46116 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46117 }
46118 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46119 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46120 }
46121 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46122 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46123 }
46124 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46125 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46126 }
46127 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46128 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46129 }
46130 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46131 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46132 }
46133 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46134 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46135 }
46136 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46138 }
46139 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46140 return (void *)((wxEvent *) ((wxPyEvent *) x));
46141 }
46142 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46143 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46144 }
46145 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46146 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46147 }
46148 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46150 }
46151 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46152 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46153 }
46154 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46155 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46156 }
46157 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46158 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46159 }
46160 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46161 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46162 }
46163 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46164 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46165 }
46166 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46167 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46168 }
46169 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46171 }
46172 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46173 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46174 }
46175 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46176 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46177 }
46178 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46180 }
46181 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46182 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46183 }
46184 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46185 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46186 }
46187 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46188 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46189 }
46190 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46191 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46192 }
46193 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46194 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46195 }
46196 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46197 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46198 }
46199 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46200 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46201 }
46202 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46203 return (void *)((wxEvent *) ((wxShowEvent *) x));
46204 }
46205 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46206 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46207 }
46208 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46209 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46210 }
46211 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46212 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46213 }
46214 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46215 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46216 }
46217 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46218 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46219 }
46220 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46221 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46222 }
46223 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46224 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46225 }
46226 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46227 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46228 }
46229 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46230 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46231 }
46232 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46233 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46234 }
46235 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46236 return (void *)((wxControl *) ((wxControlWithItems *) x));
46237 }
46238 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46239 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46240 }
46241 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46242 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46243 }
46244 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46245 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46246 }
46247 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46248 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46249 }
46250 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46251 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46252 }
46253 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46254 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46255 }
46256 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46257 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46258 }
46259 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46260 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46261 }
46262 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46263 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46264 }
46265 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46266 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46267 }
46268 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46269 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46270 }
46271 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46272 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46273 }
46274 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46275 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46276 }
46277 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46278 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46279 }
46280 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46281 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46282 }
46283 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46284 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46285 }
46286 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46287 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46288 }
46289 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46290 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46291 }
46292 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46293 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46294 }
46295 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46296 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46297 }
46298 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46299 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46300 }
46301 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46302 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46303 }
46304 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46305 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46306 }
46307 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46308 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46309 }
46310 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46311 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46312 }
46313 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46314 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46315 }
46316 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46317 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46318 }
46319 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46320 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46321 }
46322 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46323 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46324 }
46325 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46326 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46327 }
46328 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46329 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46330 }
46331 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46332 return (void *)((wxObject *) ((wxSizerItem *) x));
46333 }
46334 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46335 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46336 }
46337 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46338 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46339 }
46340 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46341 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46342 }
46343 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46344 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46345 }
46346 static void *_p_wxSizerTo_p_wxObject(void *x) {
46347 return (void *)((wxObject *) ((wxSizer *) x));
46348 }
46349 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46350 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46351 }
46352 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46354 }
46355 static void *_p_wxEventTo_p_wxObject(void *x) {
46356 return (void *)((wxObject *) ((wxEvent *) x));
46357 }
46358 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46359 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46360 }
46361 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46362 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46363 }
46364 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46365 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46366 }
46367 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46368 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46369 }
46370 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46371 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46372 }
46373 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46374 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46375 }
46376 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46377 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46378 }
46379 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46380 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46381 }
46382 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46383 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46384 }
46385 static void *_p_wxControlTo_p_wxObject(void *x) {
46386 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46387 }
46388 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46389 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46390 }
46391 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46392 return (void *)((wxObject *) ((wxFSFile *) x));
46393 }
46394 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46395 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46396 }
46397 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46398 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46399 }
46400 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46402 }
46403 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46404 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46405 }
46406 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46407 return (void *)((wxObject *) ((wxMenuItem *) x));
46408 }
46409 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46410 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46411 }
46412 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46413 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46414 }
46415 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46416 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46417 }
46418 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46419 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46420 }
46421 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46422 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46423 }
46424 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46425 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46426 }
46427 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46428 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46429 }
46430 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46431 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46432 }
46433 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46434 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46435 }
46436 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46437 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46438 }
46439 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46440 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46441 }
46442 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46443 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46444 }
46445 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46446 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46447 }
46448 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46449 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46450 }
46451 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46452 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46453 }
46454 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46455 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46456 }
46457 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46458 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46459 }
46460 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46461 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46462 }
46463 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46464 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46465 }
46466 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46467 return (void *)((wxObject *) ((wxImageHandler *) x));
46468 }
46469 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46470 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46471 }
46472 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46473 return (void *)((wxObject *) ((wxEvtHandler *) x));
46474 }
46475 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46476 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46477 }
46478 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46479 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46480 }
46481 static void *_p_wxImageTo_p_wxObject(void *x) {
46482 return (void *)((wxObject *) ((wxImage *) x));
46483 }
46484 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46485 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46486 }
46487 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46489 }
46490 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46491 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46492 }
46493 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46494 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46495 }
46496 static void *_p_wxWindowTo_p_wxObject(void *x) {
46497 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46498 }
46499 static void *_p_wxMenuTo_p_wxObject(void *x) {
46500 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46501 }
46502 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46503 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46504 }
46505 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46506 return (void *)((wxObject *) ((wxFileSystem *) x));
46507 }
46508 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46510 }
46511 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46512 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46513 }
46514 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46515 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46516 }
46517 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46518 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46519 }
46520 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46521 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46522 }
46523 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46524 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46525 }
46526 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46527 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46528 }
46529 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46530 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46531 }
46532 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46533 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46534 }
46535 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46536 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46537 }
46538 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46539 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46540 }
46541 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46542 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46543 }
46544 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46545 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46546 }
46547 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46548 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46549 }
46550 static void *_p_wxControlTo_p_wxWindow(void *x) {
46551 return (void *)((wxWindow *) ((wxControl *) x));
46552 }
46553 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46554 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46555 }
46556 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46557 return (void *)((wxWindow *) ((wxMenuBar *) x));
46558 }
46559 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46560 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46561 }
46562 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46563 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46564 }
46565 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46566 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46567 }
46568 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46569 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46570 }
46571 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46572 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46573 }
46574 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46575 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46576 }
46577 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46578 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46579 }
46580 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46581 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46582 }
46583 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46584 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46585 }
46586 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46587 return (void *)((wxValidator *) ((wxPyValidator *) x));
46588 }
46589 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}};
46590 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}};
46591 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}};
46592 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}};
46593 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}};
46594 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}};
46595 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}};
46596 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}};
46597 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}};
46598 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}};
46599 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}};
46600 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}};
46601 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}};
46602 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}};
46603 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}};
46604 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}};
46605 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}};
46606 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}};
46607 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}};
46608 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}};
46609 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}};
46610 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}};
46611 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}};
46612 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}};
46613 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}};
46614 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}};
46615 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}};
46616 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}};
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 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}};
46625 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}};
46626 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}};
46627 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}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 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}};
46645 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}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 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}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664 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}};
46665 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}};
46666 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 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}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46684 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}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706 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}};
46707 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}};
46708 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}};
46709 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}};
46710 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}};
46711 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}};
46712 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}};
46713 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}};
46714 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}};
46715 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}};
46716
46717 static swig_type_info *swig_types_initial[] = {
46718 _swigt__p_wxLayoutConstraints,
46719 _swigt__p_wxRealPoint,
46720 _swigt__p_wxSizerItem,
46721 _swigt__p_wxGBSizerItem,
46722 _swigt__p_wxScrollEvent,
46723 _swigt__p_wxEventLoop,
46724 _swigt__p_wxIndividualLayoutConstraint,
46725 _swigt__p_wxSizer,
46726 _swigt__p_wxBoxSizer,
46727 _swigt__p_wxStaticBoxSizer,
46728 _swigt__p_wxGridBagSizer,
46729 _swigt__p_wxAcceleratorEntry,
46730 _swigt__p_wxUpdateUIEvent,
46731 _swigt__p_wxEvent,
46732 _swigt__p_wxMenu,
46733 _swigt__p_wxGridSizer,
46734 _swigt__p_wxFlexGridSizer,
46735 _swigt__p_wxInitDialogEvent,
46736 _swigt__p_wxItemContainer,
46737 _swigt__p_wxNcPaintEvent,
46738 _swigt__p_wxPaintEvent,
46739 _swigt__p_wxSysColourChangedEvent,
46740 _swigt__p_wxMouseCaptureChangedEvent,
46741 _swigt__p_wxDisplayChangedEvent,
46742 _swigt__p_wxPaletteChangedEvent,
46743 _swigt__p_wxControl,
46744 _swigt__p_wxFont,
46745 _swigt__p_wxMenuBarBase,
46746 _swigt__p_wxSetCursorEvent,
46747 _swigt__p_wxFSFile,
46748 _swigt__p_wxCaret,
46749 _swigt__ptrdiff_t,
46750 _swigt__std__ptrdiff_t,
46751 _swigt__p_wxRegion,
46752 _swigt__p_wxPoint2D,
46753 _swigt__p_int,
46754 _swigt__p_wxSize,
46755 _swigt__p_wxDC,
46756 _swigt__p_wxPySizer,
46757 _swigt__p_wxVisualAttributes,
46758 _swigt__p_wxNotifyEvent,
46759 _swigt__p_wxPyEvent,
46760 _swigt__p_wxPropagationDisabler,
46761 _swigt__p_form_ops_t,
46762 _swigt__p_wxAppTraits,
46763 _swigt__p_wxArrayString,
46764 _swigt__p_wxShowEvent,
46765 _swigt__p_wxToolTip,
46766 _swigt__p_wxMoveEvent,
46767 _swigt__p_wxSizeEvent,
46768 _swigt__p_wxActivateEvent,
46769 _swigt__p_wxIconizeEvent,
46770 _swigt__p_wxMaximizeEvent,
46771 _swigt__p_wxQueryNewPaletteEvent,
46772 _swigt__p_wxWindowCreateEvent,
46773 _swigt__p_wxIdleEvent,
46774 _swigt__p_wxDateEvent,
46775 _swigt__p_wxMenuItem,
46776 _swigt__p_wxStaticBox,
46777 _swigt__p_long,
46778 _swigt__p_wxDuplexMode,
46779 _swigt__p_wxTIFFHandler,
46780 _swigt__p_wxXPMHandler,
46781 _swigt__p_wxPNMHandler,
46782 _swigt__p_wxJPEGHandler,
46783 _swigt__p_wxPCXHandler,
46784 _swigt__p_wxGIFHandler,
46785 _swigt__p_wxPNGHandler,
46786 _swigt__p_wxANIHandler,
46787 _swigt__p_wxMemoryFSHandler,
46788 _swigt__p_wxZipFSHandler,
46789 _swigt__p_wxInternetFSHandler,
46790 _swigt__p_wxPyFileSystemHandler,
46791 _swigt__p_wxEvtHandler,
46792 _swigt__p_wxCURHandler,
46793 _swigt__p_wxICOHandler,
46794 _swigt__p_wxBMPHandler,
46795 _swigt__p_wxImageHandler,
46796 _swigt__p_wxFileSystemHandler,
46797 _swigt__p_wxRect,
46798 _swigt__p_wxButton,
46799 _swigt__p_wxGBSpan,
46800 _swigt__p_wxPropagateOnce,
46801 _swigt__p_wxAcceleratorTable,
46802 _swigt__p_wxStdDialogButtonSizer,
46803 _swigt__p_char,
46804 _swigt__p_wxGBPosition,
46805 _swigt__p_wxImage,
46806 _swigt__p_wxFrame,
46807 _swigt__p_wxScrollWinEvent,
46808 _swigt__p_wxPaperSize,
46809 _swigt__p_wxImageHistogram,
46810 _swigt__p_wxPoint,
46811 _swigt__p_wxCursor,
46812 _swigt__p_wxObject,
46813 _swigt__p_wxInputStream,
46814 _swigt__p_wxOutputStream,
46815 _swigt__p_wxPyInputStream,
46816 _swigt__p_wxDateTime,
46817 _swigt__p_wxKeyEvent,
46818 _swigt__p_wxNavigationKeyEvent,
46819 _swigt__p_wxWindowDestroyEvent,
46820 _swigt__p_unsigned_long,
46821 _swigt__p_wxWindow,
46822 _swigt__p_wxMenuBar,
46823 _swigt__p_wxFileSystem,
46824 _swigt__p_wxBitmap,
46825 _swigt__unsigned_int,
46826 _swigt__p_unsigned_int,
46827 _swigt__p_wxMenuEvent,
46828 _swigt__p_wxContextMenuEvent,
46829 _swigt__p_unsigned_char,
46830 _swigt__p_wxEraseEvent,
46831 _swigt__p_wxMouseEvent,
46832 _swigt__p_wxCloseEvent,
46833 _swigt__p_wxPyApp,
46834 _swigt__p_wxCommandEvent,
46835 _swigt__p_wxPyCommandEvent,
46836 _swigt__p_wxPyDropTarget,
46837 _swigt__p_wxQuantize,
46838 _swigt__p_wxChildFocusEvent,
46839 _swigt__p_wxFocusEvent,
46840 _swigt__p_wxDropFilesEvent,
46841 _swigt__p_wxControlWithItems,
46842 _swigt__p_wxColour,
46843 _swigt__p_wxValidator,
46844 _swigt__p_wxPyValidator,
46845 0
46846 };
46847
46848
46849 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46850
46851 static swig_const_info swig_const_table[] = {
46852 {0, 0, 0, 0.0, 0, 0}};
46853
46854 #ifdef __cplusplus
46855 }
46856 #endif
46857
46858
46859 #ifdef __cplusplus
46860 extern "C" {
46861 #endif
46862
46863 /* Python-specific SWIG API */
46864 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46865 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46866 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46867
46868 /* -----------------------------------------------------------------------------
46869 * global variable support code.
46870 * ----------------------------------------------------------------------------- */
46871
46872 typedef struct swig_globalvar {
46873 char *name; /* Name of global variable */
46874 PyObject *(*get_attr)(); /* Return the current value */
46875 int (*set_attr)(PyObject *); /* Set the value */
46876 struct swig_globalvar *next;
46877 } swig_globalvar;
46878
46879 typedef struct swig_varlinkobject {
46880 PyObject_HEAD
46881 swig_globalvar *vars;
46882 } swig_varlinkobject;
46883
46884 static PyObject *
46885 swig_varlink_repr(swig_varlinkobject *v) {
46886 v = v;
46887 return PyString_FromString("<Swig global variables>");
46888 }
46889
46890 static int
46891 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46892 swig_globalvar *var;
46893 flags = flags;
46894 fprintf(fp,"Swig global variables { ");
46895 for (var = v->vars; var; var=var->next) {
46896 fprintf(fp,"%s", var->name);
46897 if (var->next) fprintf(fp,", ");
46898 }
46899 fprintf(fp," }\n");
46900 return 0;
46901 }
46902
46903 static PyObject *
46904 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46905 swig_globalvar *var = v->vars;
46906 while (var) {
46907 if (strcmp(var->name,n) == 0) {
46908 return (*var->get_attr)();
46909 }
46910 var = var->next;
46911 }
46912 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46913 return NULL;
46914 }
46915
46916 static int
46917 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46918 swig_globalvar *var = v->vars;
46919 while (var) {
46920 if (strcmp(var->name,n) == 0) {
46921 return (*var->set_attr)(p);
46922 }
46923 var = var->next;
46924 }
46925 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46926 return 1;
46927 }
46928
46929 static PyTypeObject varlinktype = {
46930 PyObject_HEAD_INIT(0)
46931 0, /* Number of items in variable part (ob_size) */
46932 (char *)"swigvarlink", /* Type name (tp_name) */
46933 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46934 0, /* Itemsize (tp_itemsize) */
46935 0, /* Deallocator (tp_dealloc) */
46936 (printfunc) swig_varlink_print, /* Print (tp_print) */
46937 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46938 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46939 0, /* tp_compare */
46940 (reprfunc) swig_varlink_repr, /* tp_repr */
46941 0, /* tp_as_number */
46942 0, /* tp_as_sequence */
46943 0, /* tp_as_mapping */
46944 0, /* tp_hash */
46945 0, /* tp_call */
46946 0, /* tp_str */
46947 0, /* tp_getattro */
46948 0, /* tp_setattro */
46949 0, /* tp_as_buffer */
46950 0, /* tp_flags */
46951 0, /* tp_doc */
46952 #if PY_VERSION_HEX >= 0x02000000
46953 0, /* tp_traverse */
46954 0, /* tp_clear */
46955 #endif
46956 #if PY_VERSION_HEX >= 0x02010000
46957 0, /* tp_richcompare */
46958 0, /* tp_weaklistoffset */
46959 #endif
46960 #if PY_VERSION_HEX >= 0x02020000
46961 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46962 #endif
46963 #if PY_VERSION_HEX >= 0x02030000
46964 0, /* tp_del */
46965 #endif
46966 #ifdef COUNT_ALLOCS
46967 0,0,0,0 /* tp_alloc -> tp_next */
46968 #endif
46969 };
46970
46971 /* Create a variable linking object for use later */
46972 static PyObject *
46973 SWIG_Python_newvarlink(void) {
46974 swig_varlinkobject *result = 0;
46975 result = PyMem_NEW(swig_varlinkobject,1);
46976 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46977 result->ob_type = &varlinktype;
46978 result->vars = 0;
46979 result->ob_refcnt = 0;
46980 Py_XINCREF((PyObject *) result);
46981 return ((PyObject*) result);
46982 }
46983
46984 static void
46985 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46986 swig_varlinkobject *v;
46987 swig_globalvar *gv;
46988 v= (swig_varlinkobject *) p;
46989 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46990 gv->name = (char *) malloc(strlen(name)+1);
46991 strcpy(gv->name,name);
46992 gv->get_attr = get_attr;
46993 gv->set_attr = set_attr;
46994 gv->next = v->vars;
46995 v->vars = gv;
46996 }
46997
46998 /* -----------------------------------------------------------------------------
46999 * constants/methods manipulation
47000 * ----------------------------------------------------------------------------- */
47001
47002 /* Install Constants */
47003 static void
47004 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47005 PyObject *obj = 0;
47006 size_t i;
47007 for (i = 0; constants[i].type; i++) {
47008 switch(constants[i].type) {
47009 case SWIG_PY_INT:
47010 obj = PyInt_FromLong(constants[i].lvalue);
47011 break;
47012 case SWIG_PY_FLOAT:
47013 obj = PyFloat_FromDouble(constants[i].dvalue);
47014 break;
47015 case SWIG_PY_STRING:
47016 if (constants[i].pvalue) {
47017 obj = PyString_FromString((char *) constants[i].pvalue);
47018 } else {
47019 Py_INCREF(Py_None);
47020 obj = Py_None;
47021 }
47022 break;
47023 case SWIG_PY_POINTER:
47024 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47025 break;
47026 case SWIG_PY_BINARY:
47027 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47028 break;
47029 default:
47030 obj = 0;
47031 break;
47032 }
47033 if (obj) {
47034 PyDict_SetItemString(d,constants[i].name,obj);
47035 Py_DECREF(obj);
47036 }
47037 }
47038 }
47039
47040 /* -----------------------------------------------------------------------------*/
47041 /* Fix SwigMethods to carry the callback ptrs when needed */
47042 /* -----------------------------------------------------------------------------*/
47043
47044 static void
47045 SWIG_Python_FixMethods(PyMethodDef *methods,
47046 swig_const_info *const_table,
47047 swig_type_info **types,
47048 swig_type_info **types_initial) {
47049 size_t i;
47050 for (i = 0; methods[i].ml_name; ++i) {
47051 char *c = methods[i].ml_doc;
47052 if (c && (c = strstr(c, "swig_ptr: "))) {
47053 int j;
47054 swig_const_info *ci = 0;
47055 char *name = c + 10;
47056 for (j = 0; const_table[j].type; j++) {
47057 if (strncmp(const_table[j].name, name,
47058 strlen(const_table[j].name)) == 0) {
47059 ci = &(const_table[j]);
47060 break;
47061 }
47062 }
47063 if (ci) {
47064 size_t shift = (ci->ptype) - types;
47065 swig_type_info *ty = types_initial[shift];
47066 size_t ldoc = (c - methods[i].ml_doc);
47067 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47068 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47069 char *buff = ndoc;
47070 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47071 strncpy(buff, methods[i].ml_doc, ldoc);
47072 buff += ldoc;
47073 strncpy(buff, "swig_ptr: ", 10);
47074 buff += 10;
47075 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47076 methods[i].ml_doc = ndoc;
47077 }
47078 }
47079 }
47080 }
47081
47082 /* -----------------------------------------------------------------------------*
47083 * Initialize type list
47084 * -----------------------------------------------------------------------------*/
47085
47086 #if PY_MAJOR_VERSION < 2
47087 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47088 is copied out of Python/modsupport.c in python version 2.3.4 */
47089 static int
47090 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47091 {
47092 PyObject *dict;
47093 if (!PyModule_Check(m)) {
47094 PyErr_SetString(PyExc_TypeError,
47095 "PyModule_AddObject() needs module as first arg");
47096 return -1;
47097 }
47098 if (!o) {
47099 PyErr_SetString(PyExc_TypeError,
47100 "PyModule_AddObject() needs non-NULL value");
47101 return -1;
47102 }
47103
47104 dict = PyModule_GetDict(m);
47105 if (dict == NULL) {
47106 /* Internal error -- modules must have a dict! */
47107 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47108 PyModule_GetName(m));
47109 return -1;
47110 }
47111 if (PyDict_SetItemString(dict, name, o))
47112 return -1;
47113 Py_DECREF(o);
47114 return 0;
47115 }
47116 #endif
47117
47118 static swig_type_info **
47119 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47120 static PyMethodDef swig_empty_runtime_method_table[] = {
47121 {
47122 NULL, NULL, 0, NULL
47123 }
47124 };/* Sentinel */
47125
47126 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47127 swig_empty_runtime_method_table);
47128 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47129 if (pointer && module) {
47130 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47131 }
47132 return type_list_handle;
47133 }
47134
47135 static swig_type_info **
47136 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47137 swig_type_info **type_pointer;
47138
47139 /* first check if module already created */
47140 type_pointer = SWIG_Python_GetTypeListHandle();
47141 if (type_pointer) {
47142 return type_pointer;
47143 } else {
47144 /* create a new module and variable */
47145 return SWIG_Python_SetTypeListHandle(type_list_handle);
47146 }
47147 }
47148
47149 #ifdef __cplusplus
47150 }
47151 #endif
47152
47153 /* -----------------------------------------------------------------------------*
47154 * Partial Init method
47155 * -----------------------------------------------------------------------------*/
47156
47157 #ifdef SWIG_LINK_RUNTIME
47158 #ifdef __cplusplus
47159 extern "C"
47160 #endif
47161 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47162 #endif
47163
47164 #ifdef __cplusplus
47165 extern "C"
47166 #endif
47167 SWIGEXPORT(void) SWIG_init(void) {
47168 static PyObject *SWIG_globals = 0;
47169 static int typeinit = 0;
47170 PyObject *m, *d;
47171 int i;
47172 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47173
47174 /* Fix SwigMethods to carry the callback ptrs when needed */
47175 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47176
47177 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47178 d = PyModule_GetDict(m);
47179
47180 if (!typeinit) {
47181 #ifdef SWIG_LINK_RUNTIME
47182 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47183 #else
47184 # ifndef SWIG_STATIC_RUNTIME
47185 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47186 # endif
47187 #endif
47188 for (i = 0; swig_types_initial[i]; i++) {
47189 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47190 }
47191 typeinit = 1;
47192 }
47193 SWIG_InstallConstants(d,swig_const_table);
47194
47195
47196 #ifndef wxPyUSE_EXPORT
47197 // Make our API structure a CObject so other modules can import it
47198 // from this module.
47199 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47200 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47201 Py_XDECREF(cobj);
47202 #endif
47203
47204 {
47205 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47206 }
47207 {
47208 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47209 }
47210 {
47211 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47212 }
47213 {
47214 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47215 }
47216 {
47217 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47218 }
47219 {
47220 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47221 }
47222 {
47223 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47224 }
47225 {
47226 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47227 }
47228 {
47229 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47230 }
47231 {
47232 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47233 }
47234 {
47235 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47236 }
47237 {
47238 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47239 }
47240 {
47241 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47242 }
47243 {
47244 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47245 }
47246 {
47247 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47248 }
47249 {
47250 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47251 }
47252 {
47253 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47254 }
47255 {
47256 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47257 }
47258 {
47259 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47260 }
47261 {
47262 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47263 }
47264 {
47265 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47266 }
47267 {
47268 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47269 }
47270 {
47271 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47272 }
47273 {
47274 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47275 }
47276 {
47277 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47278 }
47279 {
47280 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47281 }
47282 {
47283 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47284 }
47285 {
47286 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47287 }
47288 {
47289 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47290 }
47291 {
47292 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47293 }
47294 {
47295 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47296 }
47297 {
47298 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47299 }
47300 {
47301 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47302 }
47303 {
47304 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47305 }
47306 {
47307 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47308 }
47309 {
47310 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47311 }
47312 {
47313 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47314 }
47315 {
47316 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47317 }
47318 {
47319 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47320 }
47321 {
47322 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47323 }
47324 {
47325 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47326 }
47327 {
47328 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47329 }
47330 {
47331 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47332 }
47333 {
47334 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47335 }
47336 {
47337 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47338 }
47339 {
47340 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47341 }
47342 {
47343 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47344 }
47345 {
47346 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47347 }
47348 {
47349 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47350 }
47351 {
47352 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47353 }
47354 {
47355 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47356 }
47357 {
47358 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47359 }
47360 {
47361 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47362 }
47363 {
47364 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47365 }
47366 {
47367 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47368 }
47369 {
47370 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47371 }
47372 {
47373 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47374 }
47375 {
47376 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47377 }
47378 {
47379 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47380 }
47381 {
47382 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47383 }
47384 {
47385 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47386 }
47387 {
47388 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47389 }
47390 {
47391 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47392 }
47393 {
47394 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47395 }
47396 {
47397 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47398 }
47399 {
47400 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47401 }
47402 {
47403 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47404 }
47405 {
47406 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47407 }
47408 {
47409 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47410 }
47411 {
47412 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47413 }
47414 {
47415 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47416 }
47417 {
47418 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47419 }
47420 {
47421 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47422 }
47423 {
47424 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47425 }
47426 {
47427 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47428 }
47429 {
47430 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47431 }
47432 {
47433 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47434 }
47435 {
47436 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47437 }
47438 {
47439 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47440 }
47441 {
47442 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47443 }
47444 {
47445 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47446 }
47447 {
47448 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47449 }
47450 {
47451 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47452 }
47453 {
47454 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47455 }
47456 {
47457 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47458 }
47459 {
47460 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47461 }
47462 {
47463 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47464 }
47465 {
47466 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47467 }
47468 {
47469 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47470 }
47471 {
47472 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47473 }
47474 {
47475 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47476 }
47477 {
47478 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47479 }
47480 {
47481 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47482 }
47483 {
47484 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47485 }
47486 {
47487 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47488 }
47489 {
47490 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47491 }
47492 {
47493 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47494 }
47495 {
47496 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47497 }
47498 {
47499 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47500 }
47501 {
47502 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47503 }
47504 {
47505 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47506 }
47507 {
47508 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47509 }
47510 {
47511 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47512 }
47513 {
47514 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47515 }
47516 {
47517 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47518 }
47519 {
47520 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47521 }
47522 {
47523 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47524 }
47525 {
47526 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47527 }
47528 {
47529 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47530 }
47531 {
47532 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47533 }
47534 {
47535 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47536 }
47537 {
47538 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47539 }
47540 {
47541 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47542 }
47543 {
47544 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47545 }
47546 {
47547 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47548 }
47549 {
47550 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47551 }
47552 {
47553 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47554 }
47555 {
47556 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47557 }
47558 {
47559 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47560 }
47561 {
47562 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47563 }
47564 {
47565 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47566 }
47567 {
47568 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47569 }
47570 {
47571 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47572 }
47573 {
47574 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47575 }
47576 {
47577 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47578 }
47579 {
47580 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47581 }
47582 {
47583 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47584 }
47585 {
47586 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47587 }
47588 {
47589 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47590 }
47591 {
47592 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47593 }
47594 {
47595 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47596 }
47597 {
47598 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47599 }
47600 {
47601 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47602 }
47603 {
47604 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47605 }
47606 {
47607 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47608 }
47609 {
47610 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47611 }
47612 {
47613 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47614 }
47615 {
47616 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47617 }
47618 {
47619 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47620 }
47621 {
47622 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47623 }
47624 {
47625 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47626 }
47627 {
47628 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47629 }
47630 {
47631 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47632 }
47633 {
47634 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47635 }
47636 {
47637 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47638 }
47639 {
47640 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47641 }
47642 {
47643 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47644 }
47645 {
47646 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47647 }
47648 {
47649 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47650 }
47651 {
47652 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47653 }
47654 {
47655 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47656 }
47657 {
47658 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47659 }
47660 {
47661 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47662 }
47663 {
47664 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47665 }
47666 {
47667 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47668 }
47669 {
47670 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47671 }
47672 {
47673 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47674 }
47675 {
47676 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47677 }
47678 {
47679 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47680 }
47681 {
47682 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47683 }
47684 {
47685 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47686 }
47687 {
47688 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47689 }
47690 {
47691 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47692 }
47693 {
47694 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47695 }
47696 {
47697 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47698 }
47699 {
47700 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47701 }
47702 {
47703 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47704 }
47705 {
47706 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47707 }
47708 {
47709 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47710 }
47711 {
47712 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47713 }
47714 {
47715 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47716 }
47717 {
47718 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47719 }
47720 {
47721 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47722 }
47723 {
47724 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47725 }
47726 {
47727 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47728 }
47729 {
47730 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47731 }
47732 {
47733 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47734 }
47735 {
47736 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47737 }
47738 {
47739 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47740 }
47741 {
47742 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47743 }
47744 {
47745 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47746 }
47747 {
47748 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47749 }
47750 {
47751 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47752 }
47753 {
47754 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47755 }
47756 {
47757 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47758 }
47759 {
47760 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47761 }
47762 {
47763 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47764 }
47765 {
47766 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47767 }
47768 {
47769 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47770 }
47771 {
47772 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47773 }
47774 {
47775 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47776 }
47777 {
47778 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47779 }
47780 {
47781 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47782 }
47783 {
47784 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47785 }
47786 {
47787 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47788 }
47789 {
47790 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47791 }
47792 {
47793 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47794 }
47795 {
47796 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47797 }
47798 {
47799 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47800 }
47801 {
47802 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47803 }
47804 {
47805 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47806 }
47807 {
47808 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47959 }
47960 {
47961 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47962 }
47963 {
47964 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47965 }
47966 {
47967 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47968 }
47969 {
47970 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47971 }
47972 {
47973 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47974 }
47975 {
47976 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47977 }
47978 {
47979 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47980 }
47981 {
47982 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47983 }
47984 {
47985 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47986 }
47987 {
47988 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47989 }
47990 {
47991 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47992 }
47993 {
47994 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47995 }
47996 {
47997 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47998 }
47999 {
48000 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48001 }
48002 {
48003 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48004 }
48005 {
48006 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48007 }
48008 {
48009 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48010 }
48011 {
48012 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48013 }
48014 {
48015 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48016 }
48017 {
48018 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48019 }
48020 {
48021 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48022 }
48023 {
48024 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48025 }
48026 {
48027 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48028 }
48029 {
48030 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48031 }
48032 {
48033 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48034 }
48035 {
48036 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48037 }
48038 {
48039 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48040 }
48041 {
48042 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48043 }
48044 {
48045 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48046 }
48047 {
48048 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48049 }
48050 {
48051 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48052 }
48053 {
48054 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48055 }
48056 {
48057 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48058 }
48059 {
48060 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48061 }
48062 {
48063 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48064 }
48065 {
48066 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48067 }
48068 {
48069 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48070 }
48071 {
48072 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48073 }
48074 {
48075 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48076 }
48077 {
48078 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48079 }
48080 {
48081 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48082 }
48083 {
48084 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48085 }
48086 {
48087 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48088 }
48089 {
48090 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48091 }
48092 {
48093 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48094 }
48095 {
48096 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48097 }
48098 {
48099 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48100 }
48101 {
48102 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48103 }
48104 {
48105 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48106 }
48107 {
48108 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48109 }
48110 {
48111 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48112 }
48113 {
48114 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48115 }
48116 {
48117 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48118 }
48119 {
48120 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48121 }
48122 {
48123 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48124 }
48125 {
48126 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48127 }
48128 {
48129 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48130 }
48131 {
48132 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48133 }
48134 {
48135 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48136 }
48137 {
48138 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48139 }
48140 {
48141 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48142 }
48143 {
48144 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48145 }
48146 {
48147 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48148 }
48149 {
48150 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48151 }
48152 {
48153 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48154 }
48155 {
48156 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48157 }
48158 {
48159 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48160 }
48161 {
48162 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48163 }
48164 {
48165 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48166 }
48167 {
48168 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48169 }
48170 {
48171 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48172 }
48173 {
48174 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48175 }
48176 {
48177 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48178 }
48179 {
48180 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48181 }
48182 {
48183 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48184 }
48185 {
48186 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48187 }
48188 {
48189 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48190 }
48191 {
48192 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48193 }
48194 {
48195 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48196 }
48197 {
48198 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48199 }
48200 {
48201 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48202 }
48203 {
48204 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48205 }
48206 {
48207 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48208 }
48209 {
48210 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48211 }
48212 {
48213 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48214 }
48215 {
48216 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48223 }
48224 {
48225 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48226 }
48227 {
48228 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48229 }
48230 {
48231 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48232 }
48233 {
48234 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48235 }
48236 {
48237 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48238 }
48239 {
48240 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48241 }
48242 {
48243 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48244 }
48245 {
48246 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48247 }
48248 {
48249 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48250 }
48251 {
48252 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48253 }
48254 {
48255 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48256 }
48257 {
48258 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48259 }
48260 {
48261 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48262 }
48263 {
48264 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48265 }
48266 {
48267 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48268 }
48269 {
48270 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48271 }
48272 {
48273 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48274 }
48275 {
48276 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48277 }
48278 {
48279 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48280 }
48281 {
48282 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48283 }
48284 {
48285 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48286 }
48287 {
48288 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48289 }
48290 {
48291 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48292 }
48293 {
48294 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48295 }
48296 {
48297 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48298 }
48299 {
48300 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48301 }
48302 {
48303 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48304 }
48305 {
48306 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48307 }
48308 {
48309 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48310 }
48311 {
48312 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48313 }
48314 {
48315 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48316 }
48317 {
48318 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48319 }
48320 {
48321 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48322 }
48323 {
48324 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48325 }
48326 {
48327 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48328 }
48329 {
48330 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48808 }
48809 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48810 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48811 {
48812 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48963 }
48964 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48965 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48966 {
48967 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48974 }
48975
48976 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48977
48978
48979 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48980
48981 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48982 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48983 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48984 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48985 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48986 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48987 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48988 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48989 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48990 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
48991 {
48992 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48996 }
48997 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48998 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48999 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49000 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49001 {
49002 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49039 }
49040 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49041 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49042 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49043 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49044 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49045 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49046 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49047 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49048 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49049 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49050 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49051 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49052 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49053 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49054 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49055 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49056 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49057 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49058 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49059 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49060 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49061 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49062 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49063 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49064 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49065 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49066 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49067 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49068 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49069 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49070 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49071 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49072 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49073 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49074 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49075 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49076 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49077 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49078 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49079 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49080 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49081 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49082 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49083 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49084 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49085 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49086 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49087 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49088 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49089 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49090 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49091 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49092 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49093 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49094 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49095 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49096 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49097 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49098 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49099 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49100 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49101 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49102 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49103 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49104 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49105 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49106 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49107 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49108 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49109 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49110 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49111 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49112 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49113 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49114 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49115 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49116 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49117 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49118 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49119 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49120 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49121 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49122 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49123 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49124 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49125 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49126 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49127 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49128 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49129 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49130 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49131 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49132 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49133 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49134 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49135 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49136 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49137 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49138 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49139 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49140 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49141 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49142 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49143 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49144 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49145 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49146 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49147 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49148 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49149 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49150 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49151 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49152 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49153 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49154 {
49155 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49192 }
49193 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49194 {
49195 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49211 }
49212 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49213 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49214 {
49215 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49228 }
49229 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49230 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49231 {
49232 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49239 }
49240 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49241 {
49242 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49297 }
49298
49299 // Initialize threading, some globals and such
49300 __wxPyPreStart(d);
49301
49302
49303 // Although these are defined in __version__ they need to be here too so
49304 // that an assert can be done to ensure that the wxPython and the wxWindows
49305 // versions match.
49306 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49307 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49308 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49309
49310 }
49311
wxWidgets (Impactor)