]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Workarounds to allow compilation by Sun C++ 5.5
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 PyObject* GetTopLevelWindows() {
2770 return wxPy_ConvertList(&wxTopLevelWindows);
2771 }
2772
2773
2774 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2775 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2776 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2777
2778 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2779
2780 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2781 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2782 wxMenuItemList& list = self->GetMenuItems();
2783 return wxPy_ConvertList(&list);
2784 }
2785 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2786 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2787 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2788 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2789 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2790 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2791 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2792 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2793 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2794 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2795 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2796 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2797 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2798 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2799 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2800 static const wxString wxPyControlNameStr(wxControlNameStr);
2801 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2802 if (clientData) {
2803 wxPyClientData* data = new wxPyClientData(clientData);
2804 return self->Append(item, data);
2805 } else
2806 return self->Append(item);
2807 }
2808 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2809 if (clientData) {
2810 wxPyClientData* data = new wxPyClientData(clientData);
2811 return self->Insert(item, pos, data);
2812 } else
2813 return self->Insert(item, pos);
2814 }
2815 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2816 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2817 if (data) {
2818 Py_INCREF(data->m_obj);
2819 return data->m_obj;
2820 } else {
2821 Py_INCREF(Py_None);
2822 return Py_None;
2823 }
2824 }
2825 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2826 wxPyClientData* data = new wxPyClientData(clientData);
2827 self->SetClientObject(n, data);
2828 }
2829
2830
2831 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2832 wxPyUserData* data = NULL;
2833 if ( userData ) {
2834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2835 data = new wxPyUserData(userData);
2836 wxPyEndBlockThreads(blocked);
2837 }
2838 return new wxSizerItem(window, proportion, flag, border, data);
2839 }
2840 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2841 wxPyUserData* data = NULL;
2842 if ( userData ) {
2843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2844 data = new wxPyUserData(userData);
2845 wxPyEndBlockThreads(blocked);
2846 }
2847 return new wxSizerItem(width, height, proportion, flag, border, data);
2848 }
2849 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2850 wxPyUserData* data = NULL;
2851 if ( userData ) {
2852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2853 data = new wxPyUserData(userData);
2854 wxPyEndBlockThreads(blocked);
2855 }
2856 return new wxSizerItem(sizer, proportion, flag, border, data);
2857 }
2858
2859 #include <float.h>
2860 SWIGINTERN int
2861 SWIG_CheckDoubleInRange(double value, double min_value,
2862 double max_value, const char* errmsg)
2863 {
2864 if (value < min_value) {
2865 if (errmsg) {
2866 PyErr_Format(PyExc_OverflowError,
2867 "value %g is less than %s minimum %g",
2868 value, errmsg, min_value);
2869 }
2870 return 0;
2871 } else if (value > max_value) {
2872 if (errmsg) {
2873 PyErr_Format(PyExc_OverflowError,
2874 "value %g is greater than %s maximum %g",
2875 value, errmsg, max_value);
2876 }
2877 return 0;
2878 }
2879 return 1;
2880 }
2881
2882
2883 SWIGINTERN int
2884 SWIG_AsVal_float(PyObject *obj, float *val)
2885 {
2886 const char* errmsg = val ? "float" : (char*)0;
2887 double v;
2888 if (SWIG_AsVal_double(obj, &v)) {
2889 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2890 if (val) *val = (float)(v);
2891 return 1;
2892 } else {
2893 return 0;
2894 }
2895 } else {
2896 PyErr_Clear();
2897 }
2898 if (val) {
2899 SWIG_type_error(errmsg, obj);
2900 }
2901 return 0;
2902 }
2903
2904
2905 SWIGINTERNSHORT float
2906 SWIG_As_float(PyObject* obj)
2907 {
2908 float v;
2909 if (!SWIG_AsVal_float(obj, &v)) {
2910 /*
2911 this is needed to make valgrind/purify happier.
2912 */
2913 memset((void*)&v, 0, sizeof(float));
2914 }
2915 return v;
2916 }
2917
2918
2919 SWIGINTERNSHORT int
2920 SWIG_Check_float(PyObject* obj)
2921 {
2922 return SWIG_AsVal_float(obj, (float*)0);
2923 }
2924
2925
2926 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2927 #define SWIG_From_float PyFloat_FromDouble
2928 /*@@*/
2929
2930 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2931 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2932 if (data) {
2933 Py_INCREF(data->m_obj);
2934 return data->m_obj;
2935 } else {
2936 Py_INCREF(Py_None);
2937 return Py_None;
2938 }
2939 }
2940
2941 // Figure out the type of the sizer item
2942
2943 struct wxPySizerItemInfo {
2944 wxPySizerItemInfo()
2945 : window(NULL), sizer(NULL), gotSize(false),
2946 size(wxDefaultSize), gotPos(false), pos(-1)
2947 {}
2948
2949 wxWindow* window;
2950 wxSizer* sizer;
2951 bool gotSize;
2952 wxSize size;
2953 bool gotPos;
2954 int pos;
2955 };
2956
2957 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2958
2959 wxPySizerItemInfo info;
2960 wxSize size;
2961 wxSize* sizePtr = &size;
2962
2963 // Find out what the type of the item is
2964 // try wxWindow
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2966 PyErr_Clear();
2967 info.window = NULL;
2968
2969 // try wxSizer
2970 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2971 PyErr_Clear();
2972 info.sizer = NULL;
2973
2974 // try wxSize or (w,h)
2975 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2976 info.size = *sizePtr;
2977 info.gotSize = true;
2978 }
2979
2980 // or a single int
2981 if (checkIdx && PyInt_Check(item)) {
2982 info.pos = PyInt_AsLong(item);
2983 info.gotPos = true;
2984 }
2985 }
2986 }
2987
2988 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2989 // no expected type, figure out what kind of error message to generate
2990 if ( !checkSize && !checkIdx )
2991 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2992 else if ( checkSize && !checkIdx )
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2994 else if ( !checkSize && checkIdx)
2995 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2996 else
2997 // can this one happen?
2998 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2999 }
3000
3001 return info;
3002 }
3003
3004 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3005 if (!self->GetClientObject())
3006 self->SetClientObject(new wxPyOORClientData(_self));
3007 }
3008 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3009
3010 wxPyUserData* data = NULL;
3011 wxPyBlock_t 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 Add method if a valid item type was found
3018 if ( info.window )
3019 return self->Add(info.window, proportion, flag, border, data);
3020 else if ( info.sizer )
3021 return self->Add(info.sizer, proportion, flag, border, data);
3022 else if (info.gotSize)
3023 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3024 proportion, flag, border, data);
3025 else
3026 return NULL;
3027 }
3028 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3029
3030 wxPyUserData* data = NULL;
3031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3032 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3033 if ( userData && (info.window || info.sizer || info.gotSize) )
3034 data = new wxPyUserData(userData);
3035 wxPyEndBlockThreads(blocked);
3036
3037 // Now call the real Insert method if a valid item type was found
3038 if ( info.window )
3039 return self->Insert(before, info.window, proportion, flag, border, data);
3040 else if ( info.sizer )
3041 return self->Insert(before, info.sizer, proportion, flag, border, data);
3042 else if (info.gotSize)
3043 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3044 proportion, flag, border, data);
3045 else
3046 return NULL;
3047 }
3048 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3049
3050 wxPyUserData* data = NULL;
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3053 if ( userData && (info.window || info.sizer || info.gotSize) )
3054 data = new wxPyUserData(userData);
3055 wxPyEndBlockThreads(blocked);
3056
3057 // Now call the real Prepend method if a valid item type was found
3058 if ( info.window )
3059 return self->Prepend(info.window, proportion, flag, border, data);
3060 else if ( info.sizer )
3061 return self->Prepend(info.sizer, proportion, flag, border, data);
3062 else if (info.gotSize)
3063 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3064 proportion, flag, border, data);
3065 else
3066 return NULL;
3067 }
3068 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3071 wxPyEndBlockThreads(blocked);
3072 if ( info.window )
3073 return self->Remove(info.window);
3074 else if ( info.sizer )
3075 return self->Remove(info.sizer);
3076 else if ( info.gotPos )
3077 return self->Remove(info.pos);
3078 else
3079 return false;
3080 }
3081 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3084 wxPyEndBlockThreads(blocked);
3085 if ( info.window )
3086 return self->Detach(info.window);
3087 else if ( info.sizer )
3088 return self->Detach(info.sizer);
3089 else if ( info.gotPos )
3090 return self->Detach(info.pos);
3091 else
3092 return false;
3093 }
3094 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3095 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3096 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3097 wxPyEndBlockThreads(blocked);
3098 if ( info.window )
3099 return self->GetItem(info.window);
3100 else if ( info.sizer )
3101 return self->GetItem(info.sizer);
3102 else if ( info.gotPos )
3103 return self->GetItem(info.pos);
3104 else
3105 return NULL;
3106 }
3107 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3110 wxPyEndBlockThreads(blocked);
3111 if ( info.window )
3112 self->SetItemMinSize(info.window, size);
3113 else if ( info.sizer )
3114 self->SetItemMinSize(info.sizer, size);
3115 else if ( info.gotPos )
3116 self->SetItemMinSize(info.pos, size);
3117 }
3118 static PyObject *wxSizer_GetChildren(wxSizer *self){
3119 wxSizerItemList& list = self->GetChildren();
3120 return wxPy_ConvertList(&list);
3121 }
3122 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3123 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3124 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3125 wxPyEndBlockThreads(blocked);
3126 if ( info.window )
3127 return self->Show(info.window, show, recursive);
3128 else if ( info.sizer )
3129 return self->Show(info.sizer, show, recursive);
3130 else if ( info.gotPos )
3131 return self->Show(info.pos, show);
3132 else
3133 return false;
3134 }
3135 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3138 wxPyEndBlockThreads(blocked);
3139 if ( info.window )
3140 return self->IsShown(info.window);
3141 else if ( info.sizer )
3142 return self->IsShown(info.sizer);
3143 else if ( info.gotPos )
3144 return self->IsShown(info.pos);
3145 else
3146 return false;
3147 }
3148
3149 // See pyclasses.h
3150 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3151 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3152 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3153
3154
3155
3156
3157 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3158 {
3159 if (source == Py_None) {
3160 **obj = wxGBPosition(-1,-1);
3161 return true;
3162 }
3163 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3164 }
3165
3166 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3167 {
3168 if (source == Py_None) {
3169 **obj = wxGBSpan(-1,-1);
3170 return true;
3171 }
3172 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3173 }
3174
3175
3176 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3177 self->SetRow(row);
3178 self->SetCol(col);
3179 }
3180 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 PyObject* tup = PyTuple_New(2);
3183 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3184 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3185 wxPyEndBlockThreads(blocked);
3186 return tup;
3187 }
3188 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3189 self->SetRowspan(rowspan);
3190 self->SetColspan(colspan);
3191 }
3192 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 PyObject* tup = PyTuple_New(2);
3195 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3196 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3197 wxPyEndBlockThreads(blocked);
3198 return tup;
3199 }
3200 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3201 wxPyUserData* data = NULL;
3202 if ( userData ) {
3203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3204 data = new wxPyUserData(userData);
3205 wxPyEndBlockThreads(blocked);
3206 }
3207 return new wxGBSizerItem(window, pos, span, flag, border, data);
3208 }
3209 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3210 wxPyUserData* data = NULL;
3211 if ( userData ) {
3212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3213 data = new wxPyUserData(userData);
3214 wxPyEndBlockThreads(blocked);
3215 }
3216 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3217 }
3218 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3219 wxPyUserData* data = NULL;
3220 if ( userData ) {
3221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3222 data = new wxPyUserData(userData);
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3226 }
3227 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3228 int row, col;
3229 self->GetEndPos(row, col);
3230 return wxGBPosition(row, col);
3231 }
3232 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3233
3234 wxPyUserData* data = NULL;
3235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3237 if ( userData && (info.window || info.sizer || info.gotSize) )
3238 data = new wxPyUserData(userData);
3239 wxPyEndBlockThreads(blocked);
3240
3241 // Now call the real Add method if a valid item type was found
3242 if ( info.window )
3243 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3244 else if ( info.sizer )
3245 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3246 else if (info.gotSize)
3247 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3248 pos, span, flag, border, data);
3249 return NULL;
3250 }
3251
3252
3253 #ifdef __cplusplus
3254 extern "C" {
3255 #endif
3256 static int _wrap_EmptyString_set(PyObject *) {
3257 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3258 return 1;
3259 }
3260
3261
3262 static PyObject *_wrap_EmptyString_get(void) {
3263 PyObject *pyobj;
3264
3265 {
3266 #if wxUSE_UNICODE
3267 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3268 #else
3269 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3270 #endif
3271 }
3272 return pyobj;
3273 }
3274
3275
3276 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3277 PyObject *resultobj;
3278 wxObject *arg1 = (wxObject *) 0 ;
3279 wxString result;
3280 PyObject * obj0 = 0 ;
3281 char *kwnames[] = {
3282 (char *) "self", NULL
3283 };
3284
3285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3287 if (SWIG_arg_fail(1)) SWIG_fail;
3288 {
3289 PyThreadState* __tstate = wxPyBeginAllowThreads();
3290 result = wxObject_GetClassName(arg1);
3291
3292 wxPyEndAllowThreads(__tstate);
3293 if (PyErr_Occurred()) SWIG_fail;
3294 }
3295 {
3296 #if wxUSE_UNICODE
3297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3298 #else
3299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3300 #endif
3301 }
3302 return resultobj;
3303 fail:
3304 return NULL;
3305 }
3306
3307
3308 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3309 PyObject *resultobj;
3310 wxObject *arg1 = (wxObject *) 0 ;
3311 PyObject * obj0 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "self", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3318 if (SWIG_arg_fail(1)) SWIG_fail;
3319 {
3320 PyThreadState* __tstate = wxPyBeginAllowThreads();
3321 wxObject_Destroy(arg1);
3322
3323 wxPyEndAllowThreads(__tstate);
3324 if (PyErr_Occurred()) SWIG_fail;
3325 }
3326 Py_INCREF(Py_None); resultobj = Py_None;
3327 return resultobj;
3328 fail:
3329 return NULL;
3330 }
3331
3332
3333 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3334 PyObject *obj;
3335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3336 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3337 Py_INCREF(obj);
3338 return Py_BuildValue((char *)"");
3339 }
3340 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxSize *arg1 = (wxSize *) 0 ;
3343 int arg2 ;
3344 PyObject * obj0 = 0 ;
3345 PyObject * obj1 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "self",(char *) "x", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3352 if (SWIG_arg_fail(1)) SWIG_fail;
3353 {
3354 arg2 = (int)(SWIG_As_int(obj1));
3355 if (SWIG_arg_fail(2)) SWIG_fail;
3356 }
3357 if (arg1) (arg1)->x = arg2;
3358
3359 Py_INCREF(Py_None); resultobj = Py_None;
3360 return resultobj;
3361 fail:
3362 return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3367 PyObject *resultobj;
3368 wxSize *arg1 = (wxSize *) 0 ;
3369 int result;
3370 PyObject * obj0 = 0 ;
3371 char *kwnames[] = {
3372 (char *) "self", NULL
3373 };
3374
3375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3377 if (SWIG_arg_fail(1)) SWIG_fail;
3378 result = (int) ((arg1)->x);
3379
3380 {
3381 resultobj = SWIG_From_int((int)(result));
3382 }
3383 return resultobj;
3384 fail:
3385 return NULL;
3386 }
3387
3388
3389 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3390 PyObject *resultobj;
3391 wxSize *arg1 = (wxSize *) 0 ;
3392 int arg2 ;
3393 PyObject * obj0 = 0 ;
3394 PyObject * obj1 = 0 ;
3395 char *kwnames[] = {
3396 (char *) "self",(char *) "y", NULL
3397 };
3398
3399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3401 if (SWIG_arg_fail(1)) SWIG_fail;
3402 {
3403 arg2 = (int)(SWIG_As_int(obj1));
3404 if (SWIG_arg_fail(2)) SWIG_fail;
3405 }
3406 if (arg1) (arg1)->y = arg2;
3407
3408 Py_INCREF(Py_None); resultobj = Py_None;
3409 return resultobj;
3410 fail:
3411 return NULL;
3412 }
3413
3414
3415 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3416 PyObject *resultobj;
3417 wxSize *arg1 = (wxSize *) 0 ;
3418 int result;
3419 PyObject * obj0 = 0 ;
3420 char *kwnames[] = {
3421 (char *) "self", NULL
3422 };
3423
3424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3426 if (SWIG_arg_fail(1)) SWIG_fail;
3427 result = (int) ((arg1)->y);
3428
3429 {
3430 resultobj = SWIG_From_int((int)(result));
3431 }
3432 return resultobj;
3433 fail:
3434 return NULL;
3435 }
3436
3437
3438 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3439 PyObject *resultobj;
3440 int arg1 = (int) 0 ;
3441 int arg2 = (int) 0 ;
3442 wxSize *result;
3443 PyObject * obj0 = 0 ;
3444 PyObject * obj1 = 0 ;
3445 char *kwnames[] = {
3446 (char *) "w",(char *) "h", NULL
3447 };
3448
3449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3450 if (obj0) {
3451 {
3452 arg1 = (int)(SWIG_As_int(obj0));
3453 if (SWIG_arg_fail(1)) SWIG_fail;
3454 }
3455 }
3456 if (obj1) {
3457 {
3458 arg2 = (int)(SWIG_As_int(obj1));
3459 if (SWIG_arg_fail(2)) SWIG_fail;
3460 }
3461 }
3462 {
3463 PyThreadState* __tstate = wxPyBeginAllowThreads();
3464 result = (wxSize *)new wxSize(arg1,arg2);
3465
3466 wxPyEndAllowThreads(__tstate);
3467 if (PyErr_Occurred()) SWIG_fail;
3468 }
3469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3470 return resultobj;
3471 fail:
3472 return NULL;
3473 }
3474
3475
3476 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3477 PyObject *resultobj;
3478 wxSize *arg1 = (wxSize *) 0 ;
3479 PyObject * obj0 = 0 ;
3480 char *kwnames[] = {
3481 (char *) "self", NULL
3482 };
3483
3484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 {
3488 PyThreadState* __tstate = wxPyBeginAllowThreads();
3489 delete arg1;
3490
3491 wxPyEndAllowThreads(__tstate);
3492 if (PyErr_Occurred()) SWIG_fail;
3493 }
3494 Py_INCREF(Py_None); resultobj = Py_None;
3495 return resultobj;
3496 fail:
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj;
3503 wxSize *arg1 = (wxSize *) 0 ;
3504 wxSize *arg2 = 0 ;
3505 bool result;
3506 wxSize temp2 ;
3507 PyObject * obj0 = 0 ;
3508 PyObject * obj1 = 0 ;
3509 char *kwnames[] = {
3510 (char *) "self",(char *) "sz", NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3515 if (SWIG_arg_fail(1)) SWIG_fail;
3516 {
3517 arg2 = &temp2;
3518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3519 }
3520 {
3521 PyThreadState* __tstate = wxPyBeginAllowThreads();
3522 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3523
3524 wxPyEndAllowThreads(__tstate);
3525 if (PyErr_Occurred()) SWIG_fail;
3526 }
3527 {
3528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3529 }
3530 return resultobj;
3531 fail:
3532 return NULL;
3533 }
3534
3535
3536 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3537 PyObject *resultobj;
3538 wxSize *arg1 = (wxSize *) 0 ;
3539 wxSize *arg2 = 0 ;
3540 bool result;
3541 wxSize temp2 ;
3542 PyObject * obj0 = 0 ;
3543 PyObject * obj1 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "self",(char *) "sz", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(1)) SWIG_fail;
3551 {
3552 arg2 = &temp2;
3553 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3554 }
3555 {
3556 PyThreadState* __tstate = wxPyBeginAllowThreads();
3557 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3558
3559 wxPyEndAllowThreads(__tstate);
3560 if (PyErr_Occurred()) SWIG_fail;
3561 }
3562 {
3563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3564 }
3565 return resultobj;
3566 fail:
3567 return NULL;
3568 }
3569
3570
3571 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3572 PyObject *resultobj;
3573 wxSize *arg1 = (wxSize *) 0 ;
3574 wxSize *arg2 = 0 ;
3575 wxSize result;
3576 wxSize temp2 ;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "self",(char *) "sz", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 {
3587 arg2 = &temp2;
3588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3589 }
3590 {
3591 PyThreadState* __tstate = wxPyBeginAllowThreads();
3592 result = (arg1)->operator +((wxSize const &)*arg2);
3593
3594 wxPyEndAllowThreads(__tstate);
3595 if (PyErr_Occurred()) SWIG_fail;
3596 }
3597 {
3598 wxSize * resultptr;
3599 resultptr = new wxSize((wxSize &)(result));
3600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3601 }
3602 return resultobj;
3603 fail:
3604 return NULL;
3605 }
3606
3607
3608 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj;
3610 wxSize *arg1 = (wxSize *) 0 ;
3611 wxSize *arg2 = 0 ;
3612 wxSize result;
3613 wxSize temp2 ;
3614 PyObject * obj0 = 0 ;
3615 PyObject * obj1 = 0 ;
3616 char *kwnames[] = {
3617 (char *) "self",(char *) "sz", NULL
3618 };
3619
3620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(1)) SWIG_fail;
3623 {
3624 arg2 = &temp2;
3625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3626 }
3627 {
3628 PyThreadState* __tstate = wxPyBeginAllowThreads();
3629 result = (arg1)->operator -((wxSize const &)*arg2);
3630
3631 wxPyEndAllowThreads(__tstate);
3632 if (PyErr_Occurred()) SWIG_fail;
3633 }
3634 {
3635 wxSize * resultptr;
3636 resultptr = new wxSize((wxSize &)(result));
3637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3638 }
3639 return resultobj;
3640 fail:
3641 return NULL;
3642 }
3643
3644
3645 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3646 PyObject *resultobj;
3647 wxSize *arg1 = (wxSize *) 0 ;
3648 wxSize *arg2 = 0 ;
3649 wxSize temp2 ;
3650 PyObject * obj0 = 0 ;
3651 PyObject * obj1 = 0 ;
3652 char *kwnames[] = {
3653 (char *) "self",(char *) "sz", NULL
3654 };
3655
3656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3658 if (SWIG_arg_fail(1)) SWIG_fail;
3659 {
3660 arg2 = &temp2;
3661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3662 }
3663 {
3664 PyThreadState* __tstate = wxPyBeginAllowThreads();
3665 (arg1)->IncTo((wxSize const &)*arg2);
3666
3667 wxPyEndAllowThreads(__tstate);
3668 if (PyErr_Occurred()) SWIG_fail;
3669 }
3670 Py_INCREF(Py_None); resultobj = Py_None;
3671 return resultobj;
3672 fail:
3673 return NULL;
3674 }
3675
3676
3677 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3678 PyObject *resultobj;
3679 wxSize *arg1 = (wxSize *) 0 ;
3680 wxSize *arg2 = 0 ;
3681 wxSize temp2 ;
3682 PyObject * obj0 = 0 ;
3683 PyObject * obj1 = 0 ;
3684 char *kwnames[] = {
3685 (char *) "self",(char *) "sz", NULL
3686 };
3687
3688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3690 if (SWIG_arg_fail(1)) SWIG_fail;
3691 {
3692 arg2 = &temp2;
3693 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3694 }
3695 {
3696 PyThreadState* __tstate = wxPyBeginAllowThreads();
3697 (arg1)->DecTo((wxSize const &)*arg2);
3698
3699 wxPyEndAllowThreads(__tstate);
3700 if (PyErr_Occurred()) SWIG_fail;
3701 }
3702 Py_INCREF(Py_None); resultobj = Py_None;
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 int arg2 ;
3713 int arg3 ;
3714 PyObject * obj0 = 0 ;
3715 PyObject * obj1 = 0 ;
3716 PyObject * obj2 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "self",(char *) "w",(char *) "h", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 {
3725 arg2 = (int)(SWIG_As_int(obj1));
3726 if (SWIG_arg_fail(2)) SWIG_fail;
3727 }
3728 {
3729 arg3 = (int)(SWIG_As_int(obj2));
3730 if (SWIG_arg_fail(3)) SWIG_fail;
3731 }
3732 {
3733 PyThreadState* __tstate = wxPyBeginAllowThreads();
3734 (arg1)->Set(arg2,arg3);
3735
3736 wxPyEndAllowThreads(__tstate);
3737 if (PyErr_Occurred()) SWIG_fail;
3738 }
3739 Py_INCREF(Py_None); resultobj = Py_None;
3740 return resultobj;
3741 fail:
3742 return NULL;
3743 }
3744
3745
3746 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3747 PyObject *resultobj;
3748 wxSize *arg1 = (wxSize *) 0 ;
3749 int arg2 ;
3750 PyObject * obj0 = 0 ;
3751 PyObject * obj1 = 0 ;
3752 char *kwnames[] = {
3753 (char *) "self",(char *) "w", NULL
3754 };
3755
3756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 {
3760 arg2 = (int)(SWIG_As_int(obj1));
3761 if (SWIG_arg_fail(2)) SWIG_fail;
3762 }
3763 {
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 (arg1)->SetWidth(arg2);
3766
3767 wxPyEndAllowThreads(__tstate);
3768 if (PyErr_Occurred()) SWIG_fail;
3769 }
3770 Py_INCREF(Py_None); resultobj = Py_None;
3771 return resultobj;
3772 fail:
3773 return NULL;
3774 }
3775
3776
3777 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj;
3779 wxSize *arg1 = (wxSize *) 0 ;
3780 int arg2 ;
3781 PyObject * obj0 = 0 ;
3782 PyObject * obj1 = 0 ;
3783 char *kwnames[] = {
3784 (char *) "self",(char *) "h", NULL
3785 };
3786
3787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3789 if (SWIG_arg_fail(1)) SWIG_fail;
3790 {
3791 arg2 = (int)(SWIG_As_int(obj1));
3792 if (SWIG_arg_fail(2)) SWIG_fail;
3793 }
3794 {
3795 PyThreadState* __tstate = wxPyBeginAllowThreads();
3796 (arg1)->SetHeight(arg2);
3797
3798 wxPyEndAllowThreads(__tstate);
3799 if (PyErr_Occurred()) SWIG_fail;
3800 }
3801 Py_INCREF(Py_None); resultobj = Py_None;
3802 return resultobj;
3803 fail:
3804 return NULL;
3805 }
3806
3807
3808 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3809 PyObject *resultobj;
3810 wxSize *arg1 = (wxSize *) 0 ;
3811 int result;
3812 PyObject * obj0 = 0 ;
3813 char *kwnames[] = {
3814 (char *) "self", NULL
3815 };
3816
3817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3819 if (SWIG_arg_fail(1)) SWIG_fail;
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (int)((wxSize const *)arg1)->GetWidth();
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = SWIG_From_int((int)(result));
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj;
3838 wxSize *arg1 = (wxSize *) 0 ;
3839 int result;
3840 PyObject * obj0 = 0 ;
3841 char *kwnames[] = {
3842 (char *) "self", NULL
3843 };
3844
3845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3847 if (SWIG_arg_fail(1)) SWIG_fail;
3848 {
3849 PyThreadState* __tstate = wxPyBeginAllowThreads();
3850 result = (int)((wxSize const *)arg1)->GetHeight();
3851
3852 wxPyEndAllowThreads(__tstate);
3853 if (PyErr_Occurred()) SWIG_fail;
3854 }
3855 {
3856 resultobj = SWIG_From_int((int)(result));
3857 }
3858 return resultobj;
3859 fail:
3860 return NULL;
3861 }
3862
3863
3864 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3865 PyObject *resultobj;
3866 wxSize *arg1 = (wxSize *) 0 ;
3867 bool result;
3868 PyObject * obj0 = 0 ;
3869 char *kwnames[] = {
3870 (char *) "self", NULL
3871 };
3872
3873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3875 if (SWIG_arg_fail(1)) SWIG_fail;
3876 {
3877 PyThreadState* __tstate = wxPyBeginAllowThreads();
3878 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3879
3880 wxPyEndAllowThreads(__tstate);
3881 if (PyErr_Occurred()) SWIG_fail;
3882 }
3883 {
3884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3885 }
3886 return resultobj;
3887 fail:
3888 return NULL;
3889 }
3890
3891
3892 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3893 PyObject *resultobj;
3894 wxSize *arg1 = (wxSize *) 0 ;
3895 wxSize *arg2 = 0 ;
3896 wxSize temp2 ;
3897 PyObject * obj0 = 0 ;
3898 PyObject * obj1 = 0 ;
3899 char *kwnames[] = {
3900 (char *) "self",(char *) "size", NULL
3901 };
3902
3903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3905 if (SWIG_arg_fail(1)) SWIG_fail;
3906 {
3907 arg2 = &temp2;
3908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3909 }
3910 {
3911 PyThreadState* __tstate = wxPyBeginAllowThreads();
3912 (arg1)->SetDefaults((wxSize const &)*arg2);
3913
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 Py_INCREF(Py_None); resultobj = Py_None;
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 wxSize *arg1 = (wxSize *) 0 ;
3927 PyObject *result;
3928 PyObject * obj0 = 0 ;
3929 char *kwnames[] = {
3930 (char *) "self", NULL
3931 };
3932
3933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 {
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 result = (PyObject *)wxSize_Get(arg1);
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 resultobj = result;
3944 return resultobj;
3945 fail:
3946 return NULL;
3947 }
3948
3949
3950 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3951 PyObject *obj;
3952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3953 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3954 Py_INCREF(obj);
3955 return Py_BuildValue((char *)"");
3956 }
3957 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj;
3959 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3960 double arg2 ;
3961 PyObject * obj0 = 0 ;
3962 PyObject * obj1 = 0 ;
3963 char *kwnames[] = {
3964 (char *) "self",(char *) "x", NULL
3965 };
3966
3967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3969 if (SWIG_arg_fail(1)) SWIG_fail;
3970 {
3971 arg2 = (double)(SWIG_As_double(obj1));
3972 if (SWIG_arg_fail(2)) SWIG_fail;
3973 }
3974 if (arg1) (arg1)->x = arg2;
3975
3976 Py_INCREF(Py_None); resultobj = Py_None;
3977 return resultobj;
3978 fail:
3979 return NULL;
3980 }
3981
3982
3983 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3984 PyObject *resultobj;
3985 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3986 double result;
3987 PyObject * obj0 = 0 ;
3988 char *kwnames[] = {
3989 (char *) "self", NULL
3990 };
3991
3992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3994 if (SWIG_arg_fail(1)) SWIG_fail;
3995 result = (double) ((arg1)->x);
3996
3997 {
3998 resultobj = SWIG_From_double((double)(result));
3999 }
4000 return resultobj;
4001 fail:
4002 return NULL;
4003 }
4004
4005
4006 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4007 PyObject *resultobj;
4008 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4009 double arg2 ;
4010 PyObject * obj0 = 0 ;
4011 PyObject * obj1 = 0 ;
4012 char *kwnames[] = {
4013 (char *) "self",(char *) "y", NULL
4014 };
4015
4016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4018 if (SWIG_arg_fail(1)) SWIG_fail;
4019 {
4020 arg2 = (double)(SWIG_As_double(obj1));
4021 if (SWIG_arg_fail(2)) SWIG_fail;
4022 }
4023 if (arg1) (arg1)->y = arg2;
4024
4025 Py_INCREF(Py_None); resultobj = Py_None;
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4035 double result;
4036 PyObject * obj0 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "self", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4043 if (SWIG_arg_fail(1)) SWIG_fail;
4044 result = (double) ((arg1)->y);
4045
4046 {
4047 resultobj = SWIG_From_double((double)(result));
4048 }
4049 return resultobj;
4050 fail:
4051 return NULL;
4052 }
4053
4054
4055 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4056 PyObject *resultobj;
4057 double arg1 = (double) 0.0 ;
4058 double arg2 = (double) 0.0 ;
4059 wxRealPoint *result;
4060 PyObject * obj0 = 0 ;
4061 PyObject * obj1 = 0 ;
4062 char *kwnames[] = {
4063 (char *) "x",(char *) "y", NULL
4064 };
4065
4066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4067 if (obj0) {
4068 {
4069 arg1 = (double)(SWIG_As_double(obj0));
4070 if (SWIG_arg_fail(1)) SWIG_fail;
4071 }
4072 }
4073 if (obj1) {
4074 {
4075 arg2 = (double)(SWIG_As_double(obj1));
4076 if (SWIG_arg_fail(2)) SWIG_fail;
4077 }
4078 }
4079 {
4080 PyThreadState* __tstate = wxPyBeginAllowThreads();
4081 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4082
4083 wxPyEndAllowThreads(__tstate);
4084 if (PyErr_Occurred()) SWIG_fail;
4085 }
4086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4087 return resultobj;
4088 fail:
4089 return NULL;
4090 }
4091
4092
4093 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj;
4095 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4096 PyObject * obj0 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "self", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 {
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 delete arg1;
4107
4108 wxPyEndAllowThreads(__tstate);
4109 if (PyErr_Occurred()) SWIG_fail;
4110 }
4111 Py_INCREF(Py_None); resultobj = Py_None;
4112 return resultobj;
4113 fail:
4114 return NULL;
4115 }
4116
4117
4118 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4119 PyObject *resultobj;
4120 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4121 wxRealPoint *arg2 = 0 ;
4122 bool result;
4123 wxRealPoint temp2 ;
4124 PyObject * obj0 = 0 ;
4125 PyObject * obj1 = 0 ;
4126 char *kwnames[] = {
4127 (char *) "self",(char *) "pt", NULL
4128 };
4129
4130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4132 if (SWIG_arg_fail(1)) SWIG_fail;
4133 {
4134 arg2 = &temp2;
4135 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4136 }
4137 {
4138 PyThreadState* __tstate = wxPyBeginAllowThreads();
4139 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4140
4141 wxPyEndAllowThreads(__tstate);
4142 if (PyErr_Occurred()) SWIG_fail;
4143 }
4144 {
4145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4146 }
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj;
4155 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4156 wxRealPoint *arg2 = 0 ;
4157 bool result;
4158 wxRealPoint temp2 ;
4159 PyObject * obj0 = 0 ;
4160 PyObject * obj1 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "self",(char *) "pt", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4167 if (SWIG_arg_fail(1)) SWIG_fail;
4168 {
4169 arg2 = &temp2;
4170 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4171 }
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 {
4180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4191 wxRealPoint *arg2 = 0 ;
4192 wxRealPoint result;
4193 wxRealPoint temp2 ;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "self",(char *) "pt", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4202 if (SWIG_arg_fail(1)) SWIG_fail;
4203 {
4204 arg2 = &temp2;
4205 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4206 }
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxRealPoint * resultptr;
4216 resultptr = new wxRealPoint((wxRealPoint &)(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4228 wxRealPoint *arg2 = 0 ;
4229 wxRealPoint result;
4230 wxRealPoint temp2 ;
4231 PyObject * obj0 = 0 ;
4232 PyObject * obj1 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self",(char *) "pt", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 arg2 = &temp2;
4242 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4243 }
4244 {
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4247
4248 wxPyEndAllowThreads(__tstate);
4249 if (PyErr_Occurred()) SWIG_fail;
4250 }
4251 {
4252 wxRealPoint * resultptr;
4253 resultptr = new wxRealPoint((wxRealPoint &)(result));
4254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4255 }
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4265 double arg2 ;
4266 double arg3 ;
4267 PyObject * obj0 = 0 ;
4268 PyObject * obj1 = 0 ;
4269 PyObject * obj2 = 0 ;
4270 char *kwnames[] = {
4271 (char *) "self",(char *) "x",(char *) "y", NULL
4272 };
4273
4274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4276 if (SWIG_arg_fail(1)) SWIG_fail;
4277 {
4278 arg2 = (double)(SWIG_As_double(obj1));
4279 if (SWIG_arg_fail(2)) SWIG_fail;
4280 }
4281 {
4282 arg3 = (double)(SWIG_As_double(obj2));
4283 if (SWIG_arg_fail(3)) SWIG_fail;
4284 }
4285 {
4286 PyThreadState* __tstate = wxPyBeginAllowThreads();
4287 wxRealPoint_Set(arg1,arg2,arg3);
4288
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 Py_INCREF(Py_None); resultobj = Py_None;
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj;
4301 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4302 PyObject *result;
4303 PyObject * obj0 = 0 ;
4304 char *kwnames[] = {
4305 (char *) "self", NULL
4306 };
4307
4308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4310 if (SWIG_arg_fail(1)) SWIG_fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (PyObject *)wxRealPoint_Get(arg1);
4314
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = result;
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4326 PyObject *obj;
4327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4328 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4329 Py_INCREF(obj);
4330 return Py_BuildValue((char *)"");
4331 }
4332 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj;
4334 wxPoint *arg1 = (wxPoint *) 0 ;
4335 int arg2 ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char *kwnames[] = {
4339 (char *) "self",(char *) "x", NULL
4340 };
4341
4342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4344 if (SWIG_arg_fail(1)) SWIG_fail;
4345 {
4346 arg2 = (int)(SWIG_As_int(obj1));
4347 if (SWIG_arg_fail(2)) SWIG_fail;
4348 }
4349 if (arg1) (arg1)->x = arg2;
4350
4351 Py_INCREF(Py_None); resultobj = Py_None;
4352 return resultobj;
4353 fail:
4354 return NULL;
4355 }
4356
4357
4358 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4359 PyObject *resultobj;
4360 wxPoint *arg1 = (wxPoint *) 0 ;
4361 int result;
4362 PyObject * obj0 = 0 ;
4363 char *kwnames[] = {
4364 (char *) "self", NULL
4365 };
4366
4367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4369 if (SWIG_arg_fail(1)) SWIG_fail;
4370 result = (int) ((arg1)->x);
4371
4372 {
4373 resultobj = SWIG_From_int((int)(result));
4374 }
4375 return resultobj;
4376 fail:
4377 return NULL;
4378 }
4379
4380
4381 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4382 PyObject *resultobj;
4383 wxPoint *arg1 = (wxPoint *) 0 ;
4384 int arg2 ;
4385 PyObject * obj0 = 0 ;
4386 PyObject * obj1 = 0 ;
4387 char *kwnames[] = {
4388 (char *) "self",(char *) "y", NULL
4389 };
4390
4391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4393 if (SWIG_arg_fail(1)) SWIG_fail;
4394 {
4395 arg2 = (int)(SWIG_As_int(obj1));
4396 if (SWIG_arg_fail(2)) SWIG_fail;
4397 }
4398 if (arg1) (arg1)->y = arg2;
4399
4400 Py_INCREF(Py_None); resultobj = Py_None;
4401 return resultobj;
4402 fail:
4403 return NULL;
4404 }
4405
4406
4407 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4408 PyObject *resultobj;
4409 wxPoint *arg1 = (wxPoint *) 0 ;
4410 int result;
4411 PyObject * obj0 = 0 ;
4412 char *kwnames[] = {
4413 (char *) "self", NULL
4414 };
4415
4416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4418 if (SWIG_arg_fail(1)) SWIG_fail;
4419 result = (int) ((arg1)->y);
4420
4421 {
4422 resultobj = SWIG_From_int((int)(result));
4423 }
4424 return resultobj;
4425 fail:
4426 return NULL;
4427 }
4428
4429
4430 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4431 PyObject *resultobj;
4432 int arg1 = (int) 0 ;
4433 int arg2 = (int) 0 ;
4434 wxPoint *result;
4435 PyObject * obj0 = 0 ;
4436 PyObject * obj1 = 0 ;
4437 char *kwnames[] = {
4438 (char *) "x",(char *) "y", NULL
4439 };
4440
4441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4442 if (obj0) {
4443 {
4444 arg1 = (int)(SWIG_As_int(obj0));
4445 if (SWIG_arg_fail(1)) SWIG_fail;
4446 }
4447 }
4448 if (obj1) {
4449 {
4450 arg2 = (int)(SWIG_As_int(obj1));
4451 if (SWIG_arg_fail(2)) SWIG_fail;
4452 }
4453 }
4454 {
4455 PyThreadState* __tstate = wxPyBeginAllowThreads();
4456 result = (wxPoint *)new wxPoint(arg1,arg2);
4457
4458 wxPyEndAllowThreads(__tstate);
4459 if (PyErr_Occurred()) SWIG_fail;
4460 }
4461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4462 return resultobj;
4463 fail:
4464 return NULL;
4465 }
4466
4467
4468 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj;
4470 wxPoint *arg1 = (wxPoint *) 0 ;
4471 PyObject * obj0 = 0 ;
4472 char *kwnames[] = {
4473 (char *) "self", NULL
4474 };
4475
4476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4478 if (SWIG_arg_fail(1)) SWIG_fail;
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 delete arg1;
4482
4483 wxPyEndAllowThreads(__tstate);
4484 if (PyErr_Occurred()) SWIG_fail;
4485 }
4486 Py_INCREF(Py_None); resultobj = Py_None;
4487 return resultobj;
4488 fail:
4489 return NULL;
4490 }
4491
4492
4493 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj;
4495 wxPoint *arg1 = (wxPoint *) 0 ;
4496 wxPoint *arg2 = 0 ;
4497 bool result;
4498 wxPoint temp2 ;
4499 PyObject * obj0 = 0 ;
4500 PyObject * obj1 = 0 ;
4501 char *kwnames[] = {
4502 (char *) "self",(char *) "pt", NULL
4503 };
4504
4505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4507 if (SWIG_arg_fail(1)) SWIG_fail;
4508 {
4509 arg2 = &temp2;
4510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4511 }
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4515
4516 wxPyEndAllowThreads(__tstate);
4517 if (PyErr_Occurred()) SWIG_fail;
4518 }
4519 {
4520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4521 }
4522 return resultobj;
4523 fail:
4524 return NULL;
4525 }
4526
4527
4528 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4529 PyObject *resultobj;
4530 wxPoint *arg1 = (wxPoint *) 0 ;
4531 wxPoint *arg2 = 0 ;
4532 bool result;
4533 wxPoint temp2 ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "self",(char *) "pt", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4542 if (SWIG_arg_fail(1)) SWIG_fail;
4543 {
4544 arg2 = &temp2;
4545 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4546 }
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4550
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4564 PyObject *resultobj;
4565 wxPoint *arg1 = (wxPoint *) 0 ;
4566 wxPoint *arg2 = 0 ;
4567 wxPoint result;
4568 wxPoint temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "self",(char *) "pt", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4577 if (SWIG_arg_fail(1)) SWIG_fail;
4578 {
4579 arg2 = &temp2;
4580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (arg1)->operator +((wxPoint const &)*arg2);
4585
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 {
4590 wxPoint * resultptr;
4591 resultptr = new wxPoint((wxPoint &)(result));
4592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4593 }
4594 return resultobj;
4595 fail:
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxPoint *arg1 = (wxPoint *) 0 ;
4603 wxPoint *arg2 = 0 ;
4604 wxPoint result;
4605 wxPoint temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self",(char *) "pt", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 arg2 = &temp2;
4617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = (arg1)->operator -((wxPoint const &)*arg2);
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 {
4627 wxPoint * resultptr;
4628 resultptr = new wxPoint((wxPoint &)(result));
4629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4630 }
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj;
4639 wxPoint *arg1 = (wxPoint *) 0 ;
4640 wxPoint *arg2 = 0 ;
4641 wxPoint *result;
4642 wxPoint temp2 ;
4643 PyObject * obj0 = 0 ;
4644 PyObject * obj1 = 0 ;
4645 char *kwnames[] = {
4646 (char *) "self",(char *) "pt", NULL
4647 };
4648
4649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4651 if (SWIG_arg_fail(1)) SWIG_fail;
4652 {
4653 arg2 = &temp2;
4654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4655 }
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 {
4659 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4660 result = (wxPoint *) &_result_ref;
4661 }
4662
4663 wxPyEndAllowThreads(__tstate);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4674 PyObject *resultobj;
4675 wxPoint *arg1 = (wxPoint *) 0 ;
4676 wxPoint *arg2 = 0 ;
4677 wxPoint *result;
4678 wxPoint temp2 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char *kwnames[] = {
4682 (char *) "self",(char *) "pt", NULL
4683 };
4684
4685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4687 if (SWIG_arg_fail(1)) SWIG_fail;
4688 {
4689 arg2 = &temp2;
4690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4691 }
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 {
4695 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4696 result = (wxPoint *) &_result_ref;
4697 }
4698
4699 wxPyEndAllowThreads(__tstate);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj;
4711 wxPoint *arg1 = (wxPoint *) 0 ;
4712 long arg2 ;
4713 long arg3 ;
4714 PyObject * obj0 = 0 ;
4715 PyObject * obj1 = 0 ;
4716 PyObject * obj2 = 0 ;
4717 char *kwnames[] = {
4718 (char *) "self",(char *) "x",(char *) "y", NULL
4719 };
4720
4721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4723 if (SWIG_arg_fail(1)) SWIG_fail;
4724 {
4725 arg2 = (long)(SWIG_As_long(obj1));
4726 if (SWIG_arg_fail(2)) SWIG_fail;
4727 }
4728 {
4729 arg3 = (long)(SWIG_As_long(obj2));
4730 if (SWIG_arg_fail(3)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 wxPoint_Set(arg1,arg2,arg3);
4735
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 Py_INCREF(Py_None); resultobj = Py_None;
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj;
4748 wxPoint *arg1 = (wxPoint *) 0 ;
4749 PyObject *result;
4750 PyObject * obj0 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "self", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4757 if (SWIG_arg_fail(1)) SWIG_fail;
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 result = (PyObject *)wxPoint_Get(arg1);
4761
4762 wxPyEndAllowThreads(__tstate);
4763 if (PyErr_Occurred()) SWIG_fail;
4764 }
4765 resultobj = result;
4766 return resultobj;
4767 fail:
4768 return NULL;
4769 }
4770
4771
4772 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4773 PyObject *obj;
4774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4775 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4776 Py_INCREF(obj);
4777 return Py_BuildValue((char *)"");
4778 }
4779 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj;
4781 int arg1 = (int) 0 ;
4782 int arg2 = (int) 0 ;
4783 int arg3 = (int) 0 ;
4784 int arg4 = (int) 0 ;
4785 wxRect *result;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 PyObject * obj2 = 0 ;
4789 PyObject * obj3 = 0 ;
4790 char *kwnames[] = {
4791 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4792 };
4793
4794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4795 if (obj0) {
4796 {
4797 arg1 = (int)(SWIG_As_int(obj0));
4798 if (SWIG_arg_fail(1)) SWIG_fail;
4799 }
4800 }
4801 if (obj1) {
4802 {
4803 arg2 = (int)(SWIG_As_int(obj1));
4804 if (SWIG_arg_fail(2)) SWIG_fail;
4805 }
4806 }
4807 if (obj2) {
4808 {
4809 arg3 = (int)(SWIG_As_int(obj2));
4810 if (SWIG_arg_fail(3)) SWIG_fail;
4811 }
4812 }
4813 if (obj3) {
4814 {
4815 arg4 = (int)(SWIG_As_int(obj3));
4816 if (SWIG_arg_fail(4)) SWIG_fail;
4817 }
4818 }
4819 {
4820 PyThreadState* __tstate = wxPyBeginAllowThreads();
4821 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4822
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj;
4835 wxPoint *arg1 = 0 ;
4836 wxPoint *arg2 = 0 ;
4837 wxRect *result;
4838 wxPoint temp1 ;
4839 wxPoint temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char *kwnames[] = {
4843 (char *) "topLeft",(char *) "bottomRight", NULL
4844 };
4845
4846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4847 {
4848 arg1 = &temp1;
4849 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4850 }
4851 {
4852 arg2 = &temp2;
4853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4854 }
4855 {
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4858
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj;
4871 wxPoint *arg1 = 0 ;
4872 wxSize *arg2 = 0 ;
4873 wxRect *result;
4874 wxPoint temp1 ;
4875 wxSize temp2 ;
4876 PyObject * obj0 = 0 ;
4877 PyObject * obj1 = 0 ;
4878 char *kwnames[] = {
4879 (char *) "pos",(char *) "size", NULL
4880 };
4881
4882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4883 {
4884 arg1 = &temp1;
4885 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4886 }
4887 {
4888 arg2 = &temp2;
4889 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4890 }
4891 {
4892 PyThreadState* __tstate = wxPyBeginAllowThreads();
4893 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4894
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4906 PyObject *resultobj;
4907 wxSize *arg1 = 0 ;
4908 wxRect *result;
4909 wxSize temp1 ;
4910 PyObject * obj0 = 0 ;
4911 char *kwnames[] = {
4912 (char *) "size", NULL
4913 };
4914
4915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4916 {
4917 arg1 = &temp1;
4918 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4919 }
4920 {
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4923
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj;
4936 wxRect *arg1 = (wxRect *) 0 ;
4937 PyObject * obj0 = 0 ;
4938 char *kwnames[] = {
4939 (char *) "self", NULL
4940 };
4941
4942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4944 if (SWIG_arg_fail(1)) SWIG_fail;
4945 {
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 delete arg1;
4948
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 Py_INCREF(Py_None); resultobj = Py_None;
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj;
4961 wxRect *arg1 = (wxRect *) 0 ;
4962 int result;
4963 PyObject * obj0 = 0 ;
4964 char *kwnames[] = {
4965 (char *) "self", NULL
4966 };
4967
4968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(1)) SWIG_fail;
4971 {
4972 PyThreadState* __tstate = wxPyBeginAllowThreads();
4973 result = (int)((wxRect const *)arg1)->GetX();
4974
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 {
4979 resultobj = SWIG_From_int((int)(result));
4980 }
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxRect *arg1 = (wxRect *) 0 ;
4990 int arg2 ;
4991 PyObject * obj0 = 0 ;
4992 PyObject * obj1 = 0 ;
4993 char *kwnames[] = {
4994 (char *) "self",(char *) "x", NULL
4995 };
4996
4997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4999 if (SWIG_arg_fail(1)) SWIG_fail;
5000 {
5001 arg2 = (int)(SWIG_As_int(obj1));
5002 if (SWIG_arg_fail(2)) SWIG_fail;
5003 }
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 (arg1)->SetX(arg2);
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 Py_INCREF(Py_None); resultobj = Py_None;
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5019 PyObject *resultobj;
5020 wxRect *arg1 = (wxRect *) 0 ;
5021 int result;
5022 PyObject * obj0 = 0 ;
5023 char *kwnames[] = {
5024 (char *) "self", NULL
5025 };
5026
5027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(1)) SWIG_fail;
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (int)(arg1)->GetY();
5033
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 {
5038 resultobj = SWIG_From_int((int)(result));
5039 }
5040 return resultobj;
5041 fail:
5042 return NULL;
5043 }
5044
5045
5046 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5047 PyObject *resultobj;
5048 wxRect *arg1 = (wxRect *) 0 ;
5049 int arg2 ;
5050 PyObject * obj0 = 0 ;
5051 PyObject * obj1 = 0 ;
5052 char *kwnames[] = {
5053 (char *) "self",(char *) "y", NULL
5054 };
5055
5056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5058 if (SWIG_arg_fail(1)) SWIG_fail;
5059 {
5060 arg2 = (int)(SWIG_As_int(obj1));
5061 if (SWIG_arg_fail(2)) SWIG_fail;
5062 }
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 (arg1)->SetY(arg2);
5066
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 Py_INCREF(Py_None); resultobj = Py_None;
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj;
5079 wxRect *arg1 = (wxRect *) 0 ;
5080 int result;
5081 PyObject * obj0 = 0 ;
5082 char *kwnames[] = {
5083 (char *) "self", NULL
5084 };
5085
5086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5088 if (SWIG_arg_fail(1)) SWIG_fail;
5089 {
5090 PyThreadState* __tstate = wxPyBeginAllowThreads();
5091 result = (int)((wxRect const *)arg1)->GetWidth();
5092
5093 wxPyEndAllowThreads(__tstate);
5094 if (PyErr_Occurred()) SWIG_fail;
5095 }
5096 {
5097 resultobj = SWIG_From_int((int)(result));
5098 }
5099 return resultobj;
5100 fail:
5101 return NULL;
5102 }
5103
5104
5105 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5106 PyObject *resultobj;
5107 wxRect *arg1 = (wxRect *) 0 ;
5108 int arg2 ;
5109 PyObject * obj0 = 0 ;
5110 PyObject * obj1 = 0 ;
5111 char *kwnames[] = {
5112 (char *) "self",(char *) "w", NULL
5113 };
5114
5115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5117 if (SWIG_arg_fail(1)) SWIG_fail;
5118 {
5119 arg2 = (int)(SWIG_As_int(obj1));
5120 if (SWIG_arg_fail(2)) SWIG_fail;
5121 }
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 (arg1)->SetWidth(arg2);
5125
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 Py_INCREF(Py_None); resultobj = Py_None;
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj;
5138 wxRect *arg1 = (wxRect *) 0 ;
5139 int result;
5140 PyObject * obj0 = 0 ;
5141 char *kwnames[] = {
5142 (char *) "self", NULL
5143 };
5144
5145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5147 if (SWIG_arg_fail(1)) SWIG_fail;
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 result = (int)((wxRect const *)arg1)->GetHeight();
5151
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 {
5156 resultobj = SWIG_From_int((int)(result));
5157 }
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5165 PyObject *resultobj;
5166 wxRect *arg1 = (wxRect *) 0 ;
5167 int arg2 ;
5168 PyObject * obj0 = 0 ;
5169 PyObject * obj1 = 0 ;
5170 char *kwnames[] = {
5171 (char *) "self",(char *) "h", NULL
5172 };
5173
5174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5176 if (SWIG_arg_fail(1)) SWIG_fail;
5177 {
5178 arg2 = (int)(SWIG_As_int(obj1));
5179 if (SWIG_arg_fail(2)) SWIG_fail;
5180 }
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 (arg1)->SetHeight(arg2);
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 Py_INCREF(Py_None); resultobj = Py_None;
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj;
5197 wxRect *arg1 = (wxRect *) 0 ;
5198 wxPoint result;
5199 PyObject * obj0 = 0 ;
5200 char *kwnames[] = {
5201 (char *) "self", NULL
5202 };
5203
5204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5206 if (SWIG_arg_fail(1)) SWIG_fail;
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = ((wxRect const *)arg1)->GetPosition();
5210
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 {
5215 wxPoint * resultptr;
5216 resultptr = new wxPoint((wxPoint &)(result));
5217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj;
5227 wxRect *arg1 = (wxRect *) 0 ;
5228 wxPoint *arg2 = 0 ;
5229 wxPoint temp2 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char *kwnames[] = {
5233 (char *) "self",(char *) "p", NULL
5234 };
5235
5236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5238 if (SWIG_arg_fail(1)) SWIG_fail;
5239 {
5240 arg2 = &temp2;
5241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5242 }
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 (arg1)->SetPosition((wxPoint const &)*arg2);
5246
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 Py_INCREF(Py_None); resultobj = Py_None;
5251 return resultobj;
5252 fail:
5253 return NULL;
5254 }
5255
5256
5257 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5258 PyObject *resultobj;
5259 wxRect *arg1 = (wxRect *) 0 ;
5260 wxSize result;
5261 PyObject * obj0 = 0 ;
5262 char *kwnames[] = {
5263 (char *) "self", NULL
5264 };
5265
5266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5268 if (SWIG_arg_fail(1)) SWIG_fail;
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = ((wxRect const *)arg1)->GetSize();
5272
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 {
5277 wxSize * resultptr;
5278 resultptr = new wxSize((wxSize &)(result));
5279 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5280 }
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj;
5289 wxRect *arg1 = (wxRect *) 0 ;
5290 wxSize *arg2 = 0 ;
5291 wxSize temp2 ;
5292 PyObject * obj0 = 0 ;
5293 PyObject * obj1 = 0 ;
5294 char *kwnames[] = {
5295 (char *) "self",(char *) "s", NULL
5296 };
5297
5298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5300 if (SWIG_arg_fail(1)) SWIG_fail;
5301 {
5302 arg2 = &temp2;
5303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5304 }
5305 {
5306 PyThreadState* __tstate = wxPyBeginAllowThreads();
5307 (arg1)->SetSize((wxSize const &)*arg2);
5308
5309 wxPyEndAllowThreads(__tstate);
5310 if (PyErr_Occurred()) SWIG_fail;
5311 }
5312 Py_INCREF(Py_None); resultobj = Py_None;
5313 return resultobj;
5314 fail:
5315 return NULL;
5316 }
5317
5318
5319 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5320 PyObject *resultobj;
5321 wxRect *arg1 = (wxRect *) 0 ;
5322 bool result;
5323 PyObject * obj0 = 0 ;
5324 char *kwnames[] = {
5325 (char *) "self", NULL
5326 };
5327
5328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5330 if (SWIG_arg_fail(1)) SWIG_fail;
5331 {
5332 PyThreadState* __tstate = wxPyBeginAllowThreads();
5333 result = (bool)((wxRect const *)arg1)->IsEmpty();
5334
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 {
5339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5340 }
5341 return resultobj;
5342 fail:
5343 return NULL;
5344 }
5345
5346
5347 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5348 PyObject *resultobj;
5349 wxRect *arg1 = (wxRect *) 0 ;
5350 wxPoint result;
5351 PyObject * obj0 = 0 ;
5352 char *kwnames[] = {
5353 (char *) "self", NULL
5354 };
5355
5356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5358 if (SWIG_arg_fail(1)) SWIG_fail;
5359 {
5360 PyThreadState* __tstate = wxPyBeginAllowThreads();
5361 result = ((wxRect const *)arg1)->GetTopLeft();
5362
5363 wxPyEndAllowThreads(__tstate);
5364 if (PyErr_Occurred()) SWIG_fail;
5365 }
5366 {
5367 wxPoint * resultptr;
5368 resultptr = new wxPoint((wxPoint &)(result));
5369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5370 }
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj;
5379 wxRect *arg1 = (wxRect *) 0 ;
5380 wxPoint *arg2 = 0 ;
5381 wxPoint temp2 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char *kwnames[] = {
5385 (char *) "self",(char *) "p", NULL
5386 };
5387
5388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5390 if (SWIG_arg_fail(1)) SWIG_fail;
5391 {
5392 arg2 = &temp2;
5393 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5394 }
5395 {
5396 PyThreadState* __tstate = wxPyBeginAllowThreads();
5397 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5398
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 Py_INCREF(Py_None); resultobj = Py_None;
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj;
5411 wxRect *arg1 = (wxRect *) 0 ;
5412 wxPoint result;
5413 PyObject * obj0 = 0 ;
5414 char *kwnames[] = {
5415 (char *) "self", NULL
5416 };
5417
5418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5420 if (SWIG_arg_fail(1)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = ((wxRect const *)arg1)->GetBottomRight();
5424
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 {
5429 wxPoint * resultptr;
5430 resultptr = new wxPoint((wxPoint &)(result));
5431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5432 }
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj;
5441 wxRect *arg1 = (wxRect *) 0 ;
5442 wxPoint *arg2 = 0 ;
5443 wxPoint temp2 ;
5444 PyObject * obj0 = 0 ;
5445 PyObject * obj1 = 0 ;
5446 char *kwnames[] = {
5447 (char *) "self",(char *) "p", NULL
5448 };
5449
5450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5452 if (SWIG_arg_fail(1)) SWIG_fail;
5453 {
5454 arg2 = &temp2;
5455 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5456 }
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 Py_INCREF(Py_None); resultobj = Py_None;
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5472 PyObject *resultobj;
5473 wxRect *arg1 = (wxRect *) 0 ;
5474 int result;
5475 PyObject * obj0 = 0 ;
5476 char *kwnames[] = {
5477 (char *) "self", NULL
5478 };
5479
5480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5482 if (SWIG_arg_fail(1)) SWIG_fail;
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 result = (int)((wxRect const *)arg1)->GetLeft();
5486
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 {
5491 resultobj = SWIG_From_int((int)(result));
5492 }
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5500 PyObject *resultobj;
5501 wxRect *arg1 = (wxRect *) 0 ;
5502 int result;
5503 PyObject * obj0 = 0 ;
5504 char *kwnames[] = {
5505 (char *) "self", NULL
5506 };
5507
5508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5510 if (SWIG_arg_fail(1)) SWIG_fail;
5511 {
5512 PyThreadState* __tstate = wxPyBeginAllowThreads();
5513 result = (int)((wxRect const *)arg1)->GetTop();
5514
5515 wxPyEndAllowThreads(__tstate);
5516 if (PyErr_Occurred()) SWIG_fail;
5517 }
5518 {
5519 resultobj = SWIG_From_int((int)(result));
5520 }
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj;
5529 wxRect *arg1 = (wxRect *) 0 ;
5530 int result;
5531 PyObject * obj0 = 0 ;
5532 char *kwnames[] = {
5533 (char *) "self", NULL
5534 };
5535
5536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5538 if (SWIG_arg_fail(1)) SWIG_fail;
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (int)((wxRect const *)arg1)->GetBottom();
5542
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = SWIG_From_int((int)(result));
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj;
5557 wxRect *arg1 = (wxRect *) 0 ;
5558 int result;
5559 PyObject * obj0 = 0 ;
5560 char *kwnames[] = {
5561 (char *) "self", NULL
5562 };
5563
5564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5566 if (SWIG_arg_fail(1)) SWIG_fail;
5567 {
5568 PyThreadState* __tstate = wxPyBeginAllowThreads();
5569 result = (int)((wxRect const *)arg1)->GetRight();
5570
5571 wxPyEndAllowThreads(__tstate);
5572 if (PyErr_Occurred()) SWIG_fail;
5573 }
5574 {
5575 resultobj = SWIG_From_int((int)(result));
5576 }
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj;
5585 wxRect *arg1 = (wxRect *) 0 ;
5586 int arg2 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char *kwnames[] = {
5590 (char *) "self",(char *) "left", NULL
5591 };
5592
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5595 if (SWIG_arg_fail(1)) SWIG_fail;
5596 {
5597 arg2 = (int)(SWIG_As_int(obj1));
5598 if (SWIG_arg_fail(2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 (arg1)->SetLeft(arg2);
5603
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 Py_INCREF(Py_None); resultobj = Py_None;
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxRect *arg1 = (wxRect *) 0 ;
5617 int arg2 ;
5618 PyObject * obj0 = 0 ;
5619 PyObject * obj1 = 0 ;
5620 char *kwnames[] = {
5621 (char *) "self",(char *) "right", NULL
5622 };
5623
5624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5626 if (SWIG_arg_fail(1)) SWIG_fail;
5627 {
5628 arg2 = (int)(SWIG_As_int(obj1));
5629 if (SWIG_arg_fail(2)) SWIG_fail;
5630 }
5631 {
5632 PyThreadState* __tstate = wxPyBeginAllowThreads();
5633 (arg1)->SetRight(arg2);
5634
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 Py_INCREF(Py_None); resultobj = Py_None;
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5646 PyObject *resultobj;
5647 wxRect *arg1 = (wxRect *) 0 ;
5648 int arg2 ;
5649 PyObject * obj0 = 0 ;
5650 PyObject * obj1 = 0 ;
5651 char *kwnames[] = {
5652 (char *) "self",(char *) "top", NULL
5653 };
5654
5655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5657 if (SWIG_arg_fail(1)) SWIG_fail;
5658 {
5659 arg2 = (int)(SWIG_As_int(obj1));
5660 if (SWIG_arg_fail(2)) SWIG_fail;
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 (arg1)->SetTop(arg2);
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 Py_INCREF(Py_None); resultobj = Py_None;
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj;
5678 wxRect *arg1 = (wxRect *) 0 ;
5679 int arg2 ;
5680 PyObject * obj0 = 0 ;
5681 PyObject * obj1 = 0 ;
5682 char *kwnames[] = {
5683 (char *) "self",(char *) "bottom", NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 {
5690 arg2 = (int)(SWIG_As_int(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 PyThreadState* __tstate = wxPyBeginAllowThreads();
5695 (arg1)->SetBottom(arg2);
5696
5697 wxPyEndAllowThreads(__tstate);
5698 if (PyErr_Occurred()) SWIG_fail;
5699 }
5700 Py_INCREF(Py_None); resultobj = Py_None;
5701 return resultobj;
5702 fail:
5703 return NULL;
5704 }
5705
5706
5707 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5708 PyObject *resultobj;
5709 wxRect *arg1 = (wxRect *) 0 ;
5710 int arg2 ;
5711 int arg3 ;
5712 wxRect *result;
5713 PyObject * obj0 = 0 ;
5714 PyObject * obj1 = 0 ;
5715 PyObject * obj2 = 0 ;
5716 char *kwnames[] = {
5717 (char *) "self",(char *) "dx",(char *) "dy", NULL
5718 };
5719
5720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5722 if (SWIG_arg_fail(1)) SWIG_fail;
5723 {
5724 arg2 = (int)(SWIG_As_int(obj1));
5725 if (SWIG_arg_fail(2)) SWIG_fail;
5726 }
5727 {
5728 arg3 = (int)(SWIG_As_int(obj2));
5729 if (SWIG_arg_fail(3)) SWIG_fail;
5730 }
5731 {
5732 PyThreadState* __tstate = wxPyBeginAllowThreads();
5733 {
5734 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5735 result = (wxRect *) &_result_ref;
5736 }
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5749 PyObject *resultobj;
5750 wxRect *arg1 = (wxRect *) 0 ;
5751 int arg2 ;
5752 int arg3 ;
5753 wxRect *result;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 PyObject * obj2 = 0 ;
5757 char *kwnames[] = {
5758 (char *) "self",(char *) "dx",(char *) "dy", NULL
5759 };
5760
5761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5763 if (SWIG_arg_fail(1)) SWIG_fail;
5764 {
5765 arg2 = (int)(SWIG_As_int(obj1));
5766 if (SWIG_arg_fail(2)) SWIG_fail;
5767 }
5768 {
5769 arg3 = (int)(SWIG_As_int(obj2));
5770 if (SWIG_arg_fail(3)) SWIG_fail;
5771 }
5772 {
5773 PyThreadState* __tstate = wxPyBeginAllowThreads();
5774 {
5775 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5776 result = (wxRect *) &_result_ref;
5777 }
5778
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj;
5791 wxRect *arg1 = (wxRect *) 0 ;
5792 int arg2 ;
5793 int arg3 ;
5794 PyObject * obj0 = 0 ;
5795 PyObject * obj1 = 0 ;
5796 PyObject * obj2 = 0 ;
5797 char *kwnames[] = {
5798 (char *) "self",(char *) "dx",(char *) "dy", NULL
5799 };
5800
5801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5803 if (SWIG_arg_fail(1)) SWIG_fail;
5804 {
5805 arg2 = (int)(SWIG_As_int(obj1));
5806 if (SWIG_arg_fail(2)) SWIG_fail;
5807 }
5808 {
5809 arg3 = (int)(SWIG_As_int(obj2));
5810 if (SWIG_arg_fail(3)) SWIG_fail;
5811 }
5812 {
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 (arg1)->Offset(arg2,arg3);
5815
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 Py_INCREF(Py_None); resultobj = Py_None;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxRect *arg1 = (wxRect *) 0 ;
5829 wxPoint *arg2 = 0 ;
5830 wxPoint temp2 ;
5831 PyObject * obj0 = 0 ;
5832 PyObject * obj1 = 0 ;
5833 char *kwnames[] = {
5834 (char *) "self",(char *) "pt", NULL
5835 };
5836
5837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5839 if (SWIG_arg_fail(1)) SWIG_fail;
5840 {
5841 arg2 = &temp2;
5842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5843 }
5844 {
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 (arg1)->Offset((wxPoint const &)*arg2);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 Py_INCREF(Py_None); resultobj = Py_None;
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 wxRect *arg2 = 0 ;
5862 wxRect result;
5863 wxRect temp2 ;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "self",(char *) "rect", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (arg1)->Intersect((wxRect const &)*arg2);
5880
5881 wxPyEndAllowThreads(__tstate);
5882 if (PyErr_Occurred()) SWIG_fail;
5883 }
5884 {
5885 wxRect * resultptr;
5886 resultptr = new wxRect((wxRect &)(result));
5887 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5888 }
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 wxRect *arg1 = (wxRect *) 0 ;
5898 wxRect *arg2 = 0 ;
5899 wxRect result;
5900 wxRect temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char *kwnames[] = {
5904 (char *) "self",(char *) "rect", NULL
5905 };
5906
5907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5909 if (SWIG_arg_fail(1)) SWIG_fail;
5910 {
5911 arg2 = &temp2;
5912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5913 }
5914 {
5915 PyThreadState* __tstate = wxPyBeginAllowThreads();
5916 result = (arg1)->Union((wxRect const &)*arg2);
5917
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 wxRect * resultptr;
5923 resultptr = new wxRect((wxRect &)(result));
5924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5925 }
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj;
5934 wxRect *arg1 = (wxRect *) 0 ;
5935 wxRect *arg2 = 0 ;
5936 wxRect result;
5937 wxRect temp2 ;
5938 PyObject * obj0 = 0 ;
5939 PyObject * obj1 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "self",(char *) "rect", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5954
5955 wxPyEndAllowThreads(__tstate);
5956 if (PyErr_Occurred()) SWIG_fail;
5957 }
5958 {
5959 wxRect * resultptr;
5960 resultptr = new wxRect((wxRect &)(result));
5961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5962 }
5963 return resultobj;
5964 fail:
5965 return NULL;
5966 }
5967
5968
5969 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5970 PyObject *resultobj;
5971 wxRect *arg1 = (wxRect *) 0 ;
5972 wxRect *arg2 = 0 ;
5973 wxRect *result;
5974 wxRect temp2 ;
5975 PyObject * obj0 = 0 ;
5976 PyObject * obj1 = 0 ;
5977 char *kwnames[] = {
5978 (char *) "self",(char *) "rect", NULL
5979 };
5980
5981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5983 if (SWIG_arg_fail(1)) SWIG_fail;
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 {
5991 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5992 result = (wxRect *) &_result_ref;
5993 }
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj;
6007 wxRect *arg1 = (wxRect *) 0 ;
6008 wxRect *arg2 = 0 ;
6009 bool result;
6010 wxRect temp2 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 char *kwnames[] = {
6014 (char *) "self",(char *) "rect", NULL
6015 };
6016
6017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6019 if (SWIG_arg_fail(1)) SWIG_fail;
6020 {
6021 arg2 = &temp2;
6022 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6023 }
6024 {
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxRect *arg2 = 0 ;
6044 bool result;
6045 wxRect temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "rect", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 int arg2 ;
6079 int arg3 ;
6080 bool result;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 PyObject * obj2 = 0 ;
6084 char *kwnames[] = {
6085 (char *) "self",(char *) "x",(char *) "y", NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6090 if (SWIG_arg_fail(1)) SWIG_fail;
6091 {
6092 arg2 = (int)(SWIG_As_int(obj1));
6093 if (SWIG_arg_fail(2)) SWIG_fail;
6094 }
6095 {
6096 arg3 = (int)(SWIG_As_int(obj2));
6097 if (SWIG_arg_fail(3)) SWIG_fail;
6098 }
6099 {
6100 PyThreadState* __tstate = wxPyBeginAllowThreads();
6101 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6102
6103 wxPyEndAllowThreads(__tstate);
6104 if (PyErr_Occurred()) SWIG_fail;
6105 }
6106 {
6107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6108 }
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 wxRect *arg1 = (wxRect *) 0 ;
6118 wxPoint *arg2 = 0 ;
6119 bool result;
6120 wxPoint temp2 ;
6121 PyObject * obj0 = 0 ;
6122 PyObject * obj1 = 0 ;
6123 char *kwnames[] = {
6124 (char *) "self",(char *) "pt", NULL
6125 };
6126
6127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",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 = &temp2;
6132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6133 }
6134 {
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6137
6138 wxPyEndAllowThreads(__tstate);
6139 if (PyErr_Occurred()) SWIG_fail;
6140 }
6141 {
6142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6143 }
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj;
6152 wxRect *arg1 = (wxRect *) 0 ;
6153 wxRect *arg2 = 0 ;
6154 bool result;
6155 wxRect temp2 ;
6156 PyObject * obj0 = 0 ;
6157 PyObject * obj1 = 0 ;
6158 char *kwnames[] = {
6159 (char *) "self",(char *) "rect", NULL
6160 };
6161
6162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6164 if (SWIG_arg_fail(1)) SWIG_fail;
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 {
6177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6178 }
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int arg2 ;
6189 PyObject * obj0 = 0 ;
6190 PyObject * obj1 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "self",(char *) "x", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6197 if (SWIG_arg_fail(1)) SWIG_fail;
6198 {
6199 arg2 = (int)(SWIG_As_int(obj1));
6200 if (SWIG_arg_fail(2)) SWIG_fail;
6201 }
6202 if (arg1) (arg1)->x = arg2;
6203
6204 Py_INCREF(Py_None); resultobj = Py_None;
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int result;
6215 PyObject * obj0 = 0 ;
6216 char *kwnames[] = {
6217 (char *) "self", NULL
6218 };
6219
6220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6222 if (SWIG_arg_fail(1)) SWIG_fail;
6223 result = (int) ((arg1)->x);
6224
6225 {
6226 resultobj = SWIG_From_int((int)(result));
6227 }
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int arg2 ;
6238 PyObject * obj0 = 0 ;
6239 PyObject * obj1 = 0 ;
6240 char *kwnames[] = {
6241 (char *) "self",(char *) "y", NULL
6242 };
6243
6244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6246 if (SWIG_arg_fail(1)) SWIG_fail;
6247 {
6248 arg2 = (int)(SWIG_As_int(obj1));
6249 if (SWIG_arg_fail(2)) SWIG_fail;
6250 }
6251 if (arg1) (arg1)->y = arg2;
6252
6253 Py_INCREF(Py_None); resultobj = Py_None;
6254 return resultobj;
6255 fail:
6256 return NULL;
6257 }
6258
6259
6260 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6261 PyObject *resultobj;
6262 wxRect *arg1 = (wxRect *) 0 ;
6263 int result;
6264 PyObject * obj0 = 0 ;
6265 char *kwnames[] = {
6266 (char *) "self", NULL
6267 };
6268
6269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6271 if (SWIG_arg_fail(1)) SWIG_fail;
6272 result = (int) ((arg1)->y);
6273
6274 {
6275 resultobj = SWIG_From_int((int)(result));
6276 }
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxRect *arg1 = (wxRect *) 0 ;
6286 int arg2 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self",(char *) "width", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 {
6297 arg2 = (int)(SWIG_As_int(obj1));
6298 if (SWIG_arg_fail(2)) SWIG_fail;
6299 }
6300 if (arg1) (arg1)->width = arg2;
6301
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxRect *arg1 = (wxRect *) 0 ;
6312 int result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 result = (int) ((arg1)->width);
6322
6323 {
6324 resultobj = SWIG_From_int((int)(result));
6325 }
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxRect *arg1 = (wxRect *) 0 ;
6335 int arg2 ;
6336 PyObject * obj0 = 0 ;
6337 PyObject * obj1 = 0 ;
6338 char *kwnames[] = {
6339 (char *) "self",(char *) "height", NULL
6340 };
6341
6342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6344 if (SWIG_arg_fail(1)) SWIG_fail;
6345 {
6346 arg2 = (int)(SWIG_As_int(obj1));
6347 if (SWIG_arg_fail(2)) SWIG_fail;
6348 }
6349 if (arg1) (arg1)->height = arg2;
6350
6351 Py_INCREF(Py_None); resultobj = Py_None;
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6359 PyObject *resultobj;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 int result;
6362 PyObject * obj0 = 0 ;
6363 char *kwnames[] = {
6364 (char *) "self", NULL
6365 };
6366
6367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6369 if (SWIG_arg_fail(1)) SWIG_fail;
6370 result = (int) ((arg1)->height);
6371
6372 {
6373 resultobj = SWIG_From_int((int)(result));
6374 }
6375 return resultobj;
6376 fail:
6377 return NULL;
6378 }
6379
6380
6381 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6382 PyObject *resultobj;
6383 wxRect *arg1 = (wxRect *) 0 ;
6384 int arg2 = (int) 0 ;
6385 int arg3 = (int) 0 ;
6386 int arg4 = (int) 0 ;
6387 int arg5 = (int) 0 ;
6388 PyObject * obj0 = 0 ;
6389 PyObject * obj1 = 0 ;
6390 PyObject * obj2 = 0 ;
6391 PyObject * obj3 = 0 ;
6392 PyObject * obj4 = 0 ;
6393 char *kwnames[] = {
6394 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6395 };
6396
6397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6399 if (SWIG_arg_fail(1)) SWIG_fail;
6400 if (obj1) {
6401 {
6402 arg2 = (int)(SWIG_As_int(obj1));
6403 if (SWIG_arg_fail(2)) SWIG_fail;
6404 }
6405 }
6406 if (obj2) {
6407 {
6408 arg3 = (int)(SWIG_As_int(obj2));
6409 if (SWIG_arg_fail(3)) SWIG_fail;
6410 }
6411 }
6412 if (obj3) {
6413 {
6414 arg4 = (int)(SWIG_As_int(obj3));
6415 if (SWIG_arg_fail(4)) SWIG_fail;
6416 }
6417 }
6418 if (obj4) {
6419 {
6420 arg5 = (int)(SWIG_As_int(obj4));
6421 if (SWIG_arg_fail(5)) SWIG_fail;
6422 }
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6427
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 Py_INCREF(Py_None); resultobj = Py_None;
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 PyObject *result;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (PyObject *)wxRect_Get(arg1);
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = result;
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6465 PyObject *obj;
6466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6467 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6468 Py_INCREF(obj);
6469 return Py_BuildValue((char *)"");
6470 }
6471 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj;
6473 wxRect *arg1 = (wxRect *) 0 ;
6474 wxRect *arg2 = (wxRect *) 0 ;
6475 PyObject *result;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char *kwnames[] = {
6479 (char *) "r1",(char *) "r2", NULL
6480 };
6481
6482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6484 if (SWIG_arg_fail(1)) SWIG_fail;
6485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6486 if (SWIG_arg_fail(2)) SWIG_fail;
6487 {
6488 if (!wxPyCheckForApp()) SWIG_fail;
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 result = (PyObject *)wxIntersectRect(arg1,arg2);
6491
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = result;
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 double arg1 = (double) 0.0 ;
6505 double arg2 = (double) 0.0 ;
6506 wxPoint2D *result;
6507 PyObject * obj0 = 0 ;
6508 PyObject * obj1 = 0 ;
6509 char *kwnames[] = {
6510 (char *) "x",(char *) "y", NULL
6511 };
6512
6513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6514 if (obj0) {
6515 {
6516 arg1 = (double)(SWIG_As_double(obj0));
6517 if (SWIG_arg_fail(1)) SWIG_fail;
6518 }
6519 }
6520 if (obj1) {
6521 {
6522 arg2 = (double)(SWIG_As_double(obj1));
6523 if (SWIG_arg_fail(2)) SWIG_fail;
6524 }
6525 }
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6529
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6534 return resultobj;
6535 fail:
6536 return NULL;
6537 }
6538
6539
6540 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6541 PyObject *resultobj;
6542 wxPoint2D *arg1 = 0 ;
6543 wxPoint2D *result;
6544 wxPoint2D temp1 ;
6545 PyObject * obj0 = 0 ;
6546 char *kwnames[] = {
6547 (char *) "pt", NULL
6548 };
6549
6550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6551 {
6552 arg1 = &temp1;
6553 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6554 }
6555 {
6556 PyThreadState* __tstate = wxPyBeginAllowThreads();
6557 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6558
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj;
6571 wxPoint *arg1 = 0 ;
6572 wxPoint2D *result;
6573 wxPoint temp1 ;
6574 PyObject * obj0 = 0 ;
6575 char *kwnames[] = {
6576 (char *) "pt", NULL
6577 };
6578
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6580 {
6581 arg1 = &temp1;
6582 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6583 }
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj;
6600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6601 int *arg2 = (int *) 0 ;
6602 int *arg3 = (int *) 0 ;
6603 int temp2 ;
6604 int res2 = 0 ;
6605 int temp3 ;
6606 int res3 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 char *kwnames[] = {
6609 (char *) "self", NULL
6610 };
6611
6612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6613 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 Py_INCREF(Py_None); resultobj = Py_None;
6625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj;
6637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6638 int *arg2 = (int *) 0 ;
6639 int *arg3 = (int *) 0 ;
6640 int temp2 ;
6641 int res2 = 0 ;
6642 int temp3 ;
6643 int res3 = 0 ;
6644 PyObject * obj0 = 0 ;
6645 char *kwnames[] = {
6646 (char *) "self", NULL
6647 };
6648
6649 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6650 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6653 if (SWIG_arg_fail(1)) SWIG_fail;
6654 {
6655 PyThreadState* __tstate = wxPyBeginAllowThreads();
6656 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6657
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 Py_INCREF(Py_None); resultobj = Py_None;
6662 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6663 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6664 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6665 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6666 return resultobj;
6667 fail:
6668 return NULL;
6669 }
6670
6671
6672 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6673 PyObject *resultobj;
6674 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6675 double result;
6676 PyObject * obj0 = 0 ;
6677 char *kwnames[] = {
6678 (char *) "self", NULL
6679 };
6680
6681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6683 if (SWIG_arg_fail(1)) SWIG_fail;
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6687
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = SWIG_From_double((double)(result));
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6701 PyObject *resultobj;
6702 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6703 double result;
6704 PyObject * obj0 = 0 ;
6705 char *kwnames[] = {
6706 (char *) "self", NULL
6707 };
6708
6709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6711 if (SWIG_arg_fail(1)) SWIG_fail;
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6715
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 {
6720 resultobj = SWIG_From_double((double)(result));
6721 }
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj;
6730 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6731 double arg2 ;
6732 PyObject * obj0 = 0 ;
6733 PyObject * obj1 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "self",(char *) "length", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6740 if (SWIG_arg_fail(1)) SWIG_fail;
6741 {
6742 arg2 = (double)(SWIG_As_double(obj1));
6743 if (SWIG_arg_fail(2)) SWIG_fail;
6744 }
6745 {
6746 PyThreadState* __tstate = wxPyBeginAllowThreads();
6747 (arg1)->SetVectorLength(arg2);
6748
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 Py_INCREF(Py_None); resultobj = Py_None;
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj;
6761 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6762 double arg2 ;
6763 PyObject * obj0 = 0 ;
6764 PyObject * obj1 = 0 ;
6765 char *kwnames[] = {
6766 (char *) "self",(char *) "degrees", NULL
6767 };
6768
6769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",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 = (double)(SWIG_As_double(obj1));
6774 if (SWIG_arg_fail(2)) SWIG_fail;
6775 }
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 (arg1)->SetVectorAngle(arg2);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 Py_INCREF(Py_None); resultobj = Py_None;
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6793 wxPoint2D *arg2 = 0 ;
6794 double result;
6795 wxPoint2D temp2 ;
6796 PyObject * obj0 = 0 ;
6797 PyObject * obj1 = 0 ;
6798 char *kwnames[] = {
6799 (char *) "self",(char *) "pt", NULL
6800 };
6801
6802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(1)) SWIG_fail;
6805 {
6806 arg2 = &temp2;
6807 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6808 }
6809 {
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6812
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 {
6817 resultobj = SWIG_From_double((double)(result));
6818 }
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj;
6827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6828 wxPoint2D *arg2 = 0 ;
6829 double result;
6830 wxPoint2D temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char *kwnames[] = {
6834 (char *) "self",(char *) "pt", NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6839 if (SWIG_arg_fail(1)) SWIG_fail;
6840 {
6841 arg2 = &temp2;
6842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6843 }
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6847
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 {
6852 resultobj = SWIG_From_double((double)(result));
6853 }
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6861 PyObject *resultobj;
6862 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6863 wxPoint2D *arg2 = 0 ;
6864 double result;
6865 wxPoint2D temp2 ;
6866 PyObject * obj0 = 0 ;
6867 PyObject * obj1 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self",(char *) "vec", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 arg2 = &temp2;
6877 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6878 }
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6882
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 {
6887 resultobj = SWIG_From_double((double)(result));
6888 }
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj;
6897 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6898 wxPoint2D *arg2 = 0 ;
6899 double result;
6900 wxPoint2D temp2 ;
6901 PyObject * obj0 = 0 ;
6902 PyObject * obj1 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "self",(char *) "vec", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6909 if (SWIG_arg_fail(1)) SWIG_fail;
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = SWIG_From_double((double)(result));
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj;
6932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6933 wxPoint2D result;
6934 PyObject * obj0 = 0 ;
6935 char *kwnames[] = {
6936 (char *) "self", NULL
6937 };
6938
6939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6941 if (SWIG_arg_fail(1)) SWIG_fail;
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 result = (arg1)->operator -();
6945
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 {
6950 wxPoint2D * resultptr;
6951 resultptr = new wxPoint2D((wxPoint2D &)(result));
6952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6953 }
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj;
6962 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6963 wxPoint2D *arg2 = 0 ;
6964 wxPoint2D *result;
6965 wxPoint2D temp2 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char *kwnames[] = {
6969 (char *) "self",(char *) "pt", NULL
6970 };
6971
6972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 {
6976 arg2 = &temp2;
6977 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6978 }
6979 {
6980 PyThreadState* __tstate = wxPyBeginAllowThreads();
6981 {
6982 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6983 result = (wxPoint2D *) &_result_ref;
6984 }
6985
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6999 wxPoint2D *arg2 = 0 ;
7000 wxPoint2D *result;
7001 wxPoint2D temp2 ;
7002 PyObject * obj0 = 0 ;
7003 PyObject * obj1 = 0 ;
7004 char *kwnames[] = {
7005 (char *) "self",(char *) "pt", NULL
7006 };
7007
7008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7010 if (SWIG_arg_fail(1)) SWIG_fail;
7011 {
7012 arg2 = &temp2;
7013 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7014 }
7015 {
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 {
7018 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7019 result = (wxPoint2D *) &_result_ref;
7020 }
7021
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7033 PyObject *resultobj;
7034 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7035 wxPoint2D *arg2 = 0 ;
7036 wxPoint2D *result;
7037 wxPoint2D temp2 ;
7038 PyObject * obj0 = 0 ;
7039 PyObject * obj1 = 0 ;
7040 char *kwnames[] = {
7041 (char *) "self",(char *) "pt", NULL
7042 };
7043
7044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7046 if (SWIG_arg_fail(1)) SWIG_fail;
7047 {
7048 arg2 = &temp2;
7049 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7050 }
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 {
7054 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7055 result = (wxPoint2D *) &_result_ref;
7056 }
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj;
7070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7071 wxPoint2D *arg2 = 0 ;
7072 wxPoint2D *result;
7073 wxPoint2D temp2 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 char *kwnames[] = {
7077 (char *) "self",(char *) "pt", NULL
7078 };
7079
7080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7082 if (SWIG_arg_fail(1)) SWIG_fail;
7083 {
7084 arg2 = &temp2;
7085 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7086 }
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 {
7090 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7091 result = (wxPoint2D *) &_result_ref;
7092 }
7093
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7105 PyObject *resultobj;
7106 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7107 wxPoint2D *arg2 = 0 ;
7108 bool result;
7109 wxPoint2D temp2 ;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 char *kwnames[] = {
7113 (char *) "self",(char *) "pt", NULL
7114 };
7115
7116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",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 = &temp2;
7121 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7122 }
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 {
7131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7132 }
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj;
7141 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7142 wxPoint2D *arg2 = 0 ;
7143 bool result;
7144 wxPoint2D temp2 ;
7145 PyObject * obj0 = 0 ;
7146 PyObject * obj1 = 0 ;
7147 char *kwnames[] = {
7148 (char *) "self",(char *) "pt", NULL
7149 };
7150
7151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7153 if (SWIG_arg_fail(1)) SWIG_fail;
7154 {
7155 arg2 = &temp2;
7156 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7157 }
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 {
7166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7167 }
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 double arg2 ;
7178 PyObject * obj0 = 0 ;
7179 PyObject * obj1 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "self",(char *) "m_x", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7186 if (SWIG_arg_fail(1)) SWIG_fail;
7187 {
7188 arg2 = (double)(SWIG_As_double(obj1));
7189 if (SWIG_arg_fail(2)) SWIG_fail;
7190 }
7191 if (arg1) (arg1)->m_x = arg2;
7192
7193 Py_INCREF(Py_None); resultobj = Py_None;
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj;
7202 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7203 double result;
7204 PyObject * obj0 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 result = (double) ((arg1)->m_x);
7213
7214 {
7215 resultobj = SWIG_From_double((double)(result));
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj;
7225 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7226 double arg2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char *kwnames[] = {
7230 (char *) "self",(char *) "m_y", NULL
7231 };
7232
7233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7235 if (SWIG_arg_fail(1)) SWIG_fail;
7236 {
7237 arg2 = (double)(SWIG_As_double(obj1));
7238 if (SWIG_arg_fail(2)) SWIG_fail;
7239 }
7240 if (arg1) (arg1)->m_y = arg2;
7241
7242 Py_INCREF(Py_None); resultobj = Py_None;
7243 return resultobj;
7244 fail:
7245 return NULL;
7246 }
7247
7248
7249 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7250 PyObject *resultobj;
7251 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7252 double result;
7253 PyObject * obj0 = 0 ;
7254 char *kwnames[] = {
7255 (char *) "self", NULL
7256 };
7257
7258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7260 if (SWIG_arg_fail(1)) SWIG_fail;
7261 result = (double) ((arg1)->m_y);
7262
7263 {
7264 resultobj = SWIG_From_double((double)(result));
7265 }
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj;
7274 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7275 double arg2 = (double) 0 ;
7276 double arg3 = (double) 0 ;
7277 PyObject * obj0 = 0 ;
7278 PyObject * obj1 = 0 ;
7279 PyObject * obj2 = 0 ;
7280 char *kwnames[] = {
7281 (char *) "self",(char *) "x",(char *) "y", NULL
7282 };
7283
7284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7286 if (SWIG_arg_fail(1)) SWIG_fail;
7287 if (obj1) {
7288 {
7289 arg2 = (double)(SWIG_As_double(obj1));
7290 if (SWIG_arg_fail(2)) SWIG_fail;
7291 }
7292 }
7293 if (obj2) {
7294 {
7295 arg3 = (double)(SWIG_As_double(obj2));
7296 if (SWIG_arg_fail(3)) SWIG_fail;
7297 }
7298 }
7299 {
7300 PyThreadState* __tstate = wxPyBeginAllowThreads();
7301 wxPoint2D_Set(arg1,arg2,arg3);
7302
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 Py_INCREF(Py_None); resultobj = Py_None;
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj;
7315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7316 PyObject *result;
7317 PyObject * obj0 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (PyObject *)wxPoint2D_Get(arg1);
7328
7329 wxPyEndAllowThreads(__tstate);
7330 if (PyErr_Occurred()) SWIG_fail;
7331 }
7332 resultobj = result;
7333 return resultobj;
7334 fail:
7335 return NULL;
7336 }
7337
7338
7339 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7340 PyObject *obj;
7341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7342 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7343 Py_INCREF(obj);
7344 return Py_BuildValue((char *)"");
7345 }
7346 static int _wrap_DefaultPosition_set(PyObject *) {
7347 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7348 return 1;
7349 }
7350
7351
7352 static PyObject *_wrap_DefaultPosition_get(void) {
7353 PyObject *pyobj;
7354
7355 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7356 return pyobj;
7357 }
7358
7359
7360 static int _wrap_DefaultSize_set(PyObject *) {
7361 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7362 return 1;
7363 }
7364
7365
7366 static PyObject *_wrap_DefaultSize_get(void) {
7367 PyObject *pyobj;
7368
7369 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7370 return pyobj;
7371 }
7372
7373
7374 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 PyObject *arg1 = (PyObject *) 0 ;
7377 wxPyInputStream *result;
7378 PyObject * obj0 = 0 ;
7379 char *kwnames[] = {
7380 (char *) "p", NULL
7381 };
7382
7383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7384 arg1 = obj0;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 delete arg1;
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7427 PyObject * obj0 = 0 ;
7428 char *kwnames[] = {
7429 (char *) "self", NULL
7430 };
7431
7432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7434 if (SWIG_arg_fail(1)) SWIG_fail;
7435 {
7436 PyThreadState* __tstate = wxPyBeginAllowThreads();
7437 (arg1)->close();
7438
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 Py_INCREF(Py_None); resultobj = Py_None;
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj;
7451 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7452 PyObject * obj0 = 0 ;
7453 char *kwnames[] = {
7454 (char *) "self", NULL
7455 };
7456
7457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7459 if (SWIG_arg_fail(1)) SWIG_fail;
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 (arg1)->flush();
7463
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 Py_INCREF(Py_None); resultobj = Py_None;
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj;
7476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7477 bool result;
7478 PyObject * obj0 = 0 ;
7479 char *kwnames[] = {
7480 (char *) "self", NULL
7481 };
7482
7483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7485 if (SWIG_arg_fail(1)) SWIG_fail;
7486 {
7487 PyThreadState* __tstate = wxPyBeginAllowThreads();
7488 result = (bool)(arg1)->eof();
7489
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 static PyObject *_wrap_InputStream_read(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 *) "size", NULL
7511 };
7512
7513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",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)->read(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_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj;
7538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7539 int arg2 = (int) -1 ;
7540 PyObject *result;
7541 PyObject * obj0 = 0 ;
7542 PyObject * obj1 = 0 ;
7543 char *kwnames[] = {
7544 (char *) "self",(char *) "size", NULL
7545 };
7546
7547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7549 if (SWIG_arg_fail(1)) SWIG_fail;
7550 if (obj1) {
7551 {
7552 arg2 = (int)(SWIG_As_int(obj1));
7553 if (SWIG_arg_fail(2)) SWIG_fail;
7554 }
7555 }
7556 {
7557 PyThreadState* __tstate = wxPyBeginAllowThreads();
7558 result = (PyObject *)(arg1)->readline(arg2);
7559
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 resultobj = result;
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj;
7572 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7573 int arg2 = (int) -1 ;
7574 PyObject *result;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7577 char *kwnames[] = {
7578 (char *) "self",(char *) "sizehint", NULL
7579 };
7580
7581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7583 if (SWIG_arg_fail(1)) SWIG_fail;
7584 if (obj1) {
7585 {
7586 arg2 = (int)(SWIG_As_int(obj1));
7587 if (SWIG_arg_fail(2)) SWIG_fail;
7588 }
7589 }
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (PyObject *)(arg1)->readlines(arg2);
7593
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 resultobj = result;
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7607 int arg2 ;
7608 int arg3 = (int) 0 ;
7609 PyObject * obj0 = 0 ;
7610 PyObject * obj1 = 0 ;
7611 PyObject * obj2 = 0 ;
7612 char *kwnames[] = {
7613 (char *) "self",(char *) "offset",(char *) "whence", NULL
7614 };
7615
7616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7618 if (SWIG_arg_fail(1)) SWIG_fail;
7619 {
7620 arg2 = (int)(SWIG_As_int(obj1));
7621 if (SWIG_arg_fail(2)) SWIG_fail;
7622 }
7623 if (obj2) {
7624 {
7625 arg3 = (int)(SWIG_As_int(obj2));
7626 if (SWIG_arg_fail(3)) SWIG_fail;
7627 }
7628 }
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 (arg1)->seek(arg2,arg3);
7632
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 Py_INCREF(Py_None); resultobj = Py_None;
7637 return resultobj;
7638 fail:
7639 return NULL;
7640 }
7641
7642
7643 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7644 PyObject *resultobj;
7645 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7646 int result;
7647 PyObject * obj0 = 0 ;
7648 char *kwnames[] = {
7649 (char *) "self", NULL
7650 };
7651
7652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7654 if (SWIG_arg_fail(1)) SWIG_fail;
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (int)(arg1)->tell();
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 {
7663 resultobj = SWIG_From_int((int)(result));
7664 }
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7674 char result;
7675 PyObject * obj0 = 0 ;
7676 char *kwnames[] = {
7677 (char *) "self", NULL
7678 };
7679
7680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7682 if (SWIG_arg_fail(1)) SWIG_fail;
7683 {
7684 PyThreadState* __tstate = wxPyBeginAllowThreads();
7685 result = (char)(arg1)->Peek();
7686
7687 wxPyEndAllowThreads(__tstate);
7688 if (PyErr_Occurred()) SWIG_fail;
7689 }
7690 {
7691 resultobj = SWIG_From_char((char)(result));
7692 }
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7700 PyObject *resultobj;
7701 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7702 char result;
7703 PyObject * obj0 = 0 ;
7704 char *kwnames[] = {
7705 (char *) "self", NULL
7706 };
7707
7708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7710 if (SWIG_arg_fail(1)) SWIG_fail;
7711 {
7712 PyThreadState* __tstate = wxPyBeginAllowThreads();
7713 result = (char)(arg1)->GetC();
7714
7715 wxPyEndAllowThreads(__tstate);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = SWIG_From_char((char)(result));
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj;
7729 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7730 size_t result;
7731 PyObject * obj0 = 0 ;
7732 char *kwnames[] = {
7733 (char *) "self", NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7738 if (SWIG_arg_fail(1)) SWIG_fail;
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 result = (size_t)(arg1)->LastRead();
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 {
7747 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7748 }
7749 return resultobj;
7750 fail:
7751 return NULL;
7752 }
7753
7754
7755 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7756 PyObject *resultobj;
7757 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7758 bool result;
7759 PyObject * obj0 = 0 ;
7760 char *kwnames[] = {
7761 (char *) "self", NULL
7762 };
7763
7764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7766 if (SWIG_arg_fail(1)) SWIG_fail;
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 result = (bool)(arg1)->CanRead();
7770
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 {
7775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7776 }
7777 return resultobj;
7778 fail:
7779 return NULL;
7780 }
7781
7782
7783 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7784 PyObject *resultobj;
7785 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7786 bool result;
7787 PyObject * obj0 = 0 ;
7788 char *kwnames[] = {
7789 (char *) "self", NULL
7790 };
7791
7792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7794 if (SWIG_arg_fail(1)) SWIG_fail;
7795 {
7796 PyThreadState* __tstate = wxPyBeginAllowThreads();
7797 result = (bool)(arg1)->Eof();
7798
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 {
7803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7804 }
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj;
7813 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7814 char arg2 ;
7815 bool result;
7816 PyObject * obj0 = 0 ;
7817 PyObject * obj1 = 0 ;
7818 char *kwnames[] = {
7819 (char *) "self",(char *) "c", NULL
7820 };
7821
7822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7824 if (SWIG_arg_fail(1)) SWIG_fail;
7825 {
7826 arg2 = (char)(SWIG_As_char(obj1));
7827 if (SWIG_arg_fail(2)) SWIG_fail;
7828 }
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 result = (bool)(arg1)->Ungetch(arg2);
7832
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 {
7837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7838 }
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7848 long arg2 ;
7849 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7850 long result;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 PyObject * obj2 = 0 ;
7854 char *kwnames[] = {
7855 (char *) "self",(char *) "pos",(char *) "mode", NULL
7856 };
7857
7858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7860 if (SWIG_arg_fail(1)) SWIG_fail;
7861 {
7862 arg2 = (long)(SWIG_As_long(obj1));
7863 if (SWIG_arg_fail(2)) SWIG_fail;
7864 }
7865 if (obj2) {
7866 {
7867 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7868 if (SWIG_arg_fail(3)) SWIG_fail;
7869 }
7870 }
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7874
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 {
7879 resultobj = SWIG_From_long((long)(result));
7880 }
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj;
7889 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7890 long result;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (long)(arg1)->TellI();
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 {
7907 resultobj = SWIG_From_long((long)(result));
7908 }
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7916 PyObject *obj;
7917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7918 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7919 Py_INCREF(obj);
7920 return Py_BuildValue((char *)"");
7921 }
7922 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7925 PyObject *arg2 = (PyObject *) 0 ;
7926 PyObject * obj0 = 0 ;
7927 PyObject * obj1 = 0 ;
7928 char *kwnames[] = {
7929 (char *) "self",(char *) "obj", NULL
7930 };
7931
7932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7934 if (SWIG_arg_fail(1)) SWIG_fail;
7935 arg2 = obj1;
7936 {
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 wxOutputStream_write(arg1,arg2);
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 Py_INCREF(Py_None); resultobj = Py_None;
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7951 PyObject *obj;
7952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7953 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7954 Py_INCREF(obj);
7955 return Py_BuildValue((char *)"");
7956 }
7957 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7958 PyObject *resultobj;
7959 wxInputStream *arg1 = (wxInputStream *) 0 ;
7960 wxString *arg2 = 0 ;
7961 wxString *arg3 = 0 ;
7962 wxString *arg4 = 0 ;
7963 wxDateTime arg5 ;
7964 wxFSFile *result;
7965 wxPyInputStream *temp1 ;
7966 bool temp2 = false ;
7967 bool temp3 = false ;
7968 bool temp4 = false ;
7969 PyObject * obj0 = 0 ;
7970 PyObject * obj1 = 0 ;
7971 PyObject * obj2 = 0 ;
7972 PyObject * obj3 = 0 ;
7973 PyObject * obj4 = 0 ;
7974 char *kwnames[] = {
7975 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7976 };
7977
7978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7979 {
7980 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7981 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7982 } else {
7983 PyErr_Clear(); // clear the failure of the wxPyConvert above
7984 arg1 = wxPyCBInputStream_create(obj0, true);
7985 if (arg1 == NULL) {
7986 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7987 SWIG_fail;
7988 }
7989 }
7990 }
7991 {
7992 arg2 = wxString_in_helper(obj1);
7993 if (arg2 == NULL) SWIG_fail;
7994 temp2 = true;
7995 }
7996 {
7997 arg3 = wxString_in_helper(obj2);
7998 if (arg3 == NULL) SWIG_fail;
7999 temp3 = true;
8000 }
8001 {
8002 arg4 = wxString_in_helper(obj3);
8003 if (arg4 == NULL) SWIG_fail;
8004 temp4 = true;
8005 }
8006 {
8007 wxDateTime * argp;
8008 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8009 if (SWIG_arg_fail(5)) SWIG_fail;
8010 if (argp == NULL) {
8011 SWIG_null_ref("wxDateTime");
8012 }
8013 if (SWIG_arg_fail(5)) SWIG_fail;
8014 arg5 = *argp;
8015 }
8016 {
8017 PyThreadState* __tstate = wxPyBeginAllowThreads();
8018 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8019
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 {
8024 resultobj = wxPyMake_wxObject(result, 1);
8025 }
8026 {
8027 if (temp2)
8028 delete arg2;
8029 }
8030 {
8031 if (temp3)
8032 delete arg3;
8033 }
8034 {
8035 if (temp4)
8036 delete arg4;
8037 }
8038 return resultobj;
8039 fail:
8040 {
8041 if (temp2)
8042 delete arg2;
8043 }
8044 {
8045 if (temp3)
8046 delete arg3;
8047 }
8048 {
8049 if (temp4)
8050 delete arg4;
8051 }
8052 return NULL;
8053 }
8054
8055
8056 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8057 PyObject *resultobj;
8058 wxFSFile *arg1 = (wxFSFile *) 0 ;
8059 PyObject * obj0 = 0 ;
8060 char *kwnames[] = {
8061 (char *) "self", NULL
8062 };
8063
8064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8066 if (SWIG_arg_fail(1)) SWIG_fail;
8067 {
8068 PyThreadState* __tstate = wxPyBeginAllowThreads();
8069 delete arg1;
8070
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 Py_INCREF(Py_None); resultobj = Py_None;
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8082 PyObject *resultobj;
8083 wxFSFile *arg1 = (wxFSFile *) 0 ;
8084 wxInputStream *result;
8085 PyObject * obj0 = 0 ;
8086 char *kwnames[] = {
8087 (char *) "self", NULL
8088 };
8089
8090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8092 if (SWIG_arg_fail(1)) SWIG_fail;
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (wxInputStream *)(arg1)->GetStream();
8096
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 {
8101 wxPyInputStream * _ptr = NULL;
8102
8103 if (result) {
8104 _ptr = new wxPyInputStream(result);
8105 }
8106 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8107 }
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8115 PyObject *resultobj;
8116 wxFSFile *arg1 = (wxFSFile *) 0 ;
8117 wxString *result;
8118 PyObject * obj0 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "self", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8125 if (SWIG_arg_fail(1)) SWIG_fail;
8126 {
8127 PyThreadState* __tstate = wxPyBeginAllowThreads();
8128 {
8129 wxString const &_result_ref = (arg1)->GetMimeType();
8130 result = (wxString *) &_result_ref;
8131 }
8132
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 {
8137 #if wxUSE_UNICODE
8138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8139 #else
8140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8141 #endif
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj;
8151 wxFSFile *arg1 = (wxFSFile *) 0 ;
8152 wxString *result;
8153 PyObject * obj0 = 0 ;
8154 char *kwnames[] = {
8155 (char *) "self", NULL
8156 };
8157
8158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8160 if (SWIG_arg_fail(1)) SWIG_fail;
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 {
8164 wxString const &_result_ref = (arg1)->GetLocation();
8165 result = (wxString *) &_result_ref;
8166 }
8167
8168 wxPyEndAllowThreads(__tstate);
8169 if (PyErr_Occurred()) SWIG_fail;
8170 }
8171 {
8172 #if wxUSE_UNICODE
8173 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8174 #else
8175 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8176 #endif
8177 }
8178 return resultobj;
8179 fail:
8180 return NULL;
8181 }
8182
8183
8184 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8185 PyObject *resultobj;
8186 wxFSFile *arg1 = (wxFSFile *) 0 ;
8187 wxString *result;
8188 PyObject * obj0 = 0 ;
8189 char *kwnames[] = {
8190 (char *) "self", NULL
8191 };
8192
8193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8195 if (SWIG_arg_fail(1)) SWIG_fail;
8196 {
8197 PyThreadState* __tstate = wxPyBeginAllowThreads();
8198 {
8199 wxString const &_result_ref = (arg1)->GetAnchor();
8200 result = (wxString *) &_result_ref;
8201 }
8202
8203 wxPyEndAllowThreads(__tstate);
8204 if (PyErr_Occurred()) SWIG_fail;
8205 }
8206 {
8207 #if wxUSE_UNICODE
8208 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8209 #else
8210 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8211 #endif
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxFSFile *arg1 = (wxFSFile *) 0 ;
8222 wxDateTime result;
8223 PyObject * obj0 = 0 ;
8224 char *kwnames[] = {
8225 (char *) "self", NULL
8226 };
8227
8228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8230 if (SWIG_arg_fail(1)) SWIG_fail;
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 result = (arg1)->GetModificationTime();
8234
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 {
8239 wxDateTime * resultptr;
8240 resultptr = new wxDateTime((wxDateTime &)(result));
8241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8242 }
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8250 PyObject *obj;
8251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8252 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8253 Py_INCREF(obj);
8254 return Py_BuildValue((char *)"");
8255 }
8256 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8257 PyObject *obj;
8258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8259 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8260 Py_INCREF(obj);
8261 return Py_BuildValue((char *)"");
8262 }
8263 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj;
8265 wxPyFileSystemHandler *result;
8266 char *kwnames[] = {
8267 NULL
8268 };
8269
8270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8271 {
8272 PyThreadState* __tstate = wxPyBeginAllowThreads();
8273 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8274
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj;
8287 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8288 PyObject *arg2 = (PyObject *) 0 ;
8289 PyObject *arg3 = (PyObject *) 0 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 PyObject * obj2 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "self",(char *) "self",(char *) "_class", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(1)) SWIG_fail;
8300 arg2 = obj1;
8301 arg3 = obj2;
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 (arg1)->_setCallbackInfo(arg2,arg3);
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 Py_INCREF(Py_None); resultobj = Py_None;
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj;
8318 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8319 wxString *arg2 = 0 ;
8320 bool result;
8321 bool temp2 = false ;
8322 PyObject * obj0 = 0 ;
8323 PyObject * obj1 = 0 ;
8324 char *kwnames[] = {
8325 (char *) "self",(char *) "location", NULL
8326 };
8327
8328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8330 if (SWIG_arg_fail(1)) SWIG_fail;
8331 {
8332 arg2 = wxString_in_helper(obj1);
8333 if (arg2 == NULL) SWIG_fail;
8334 temp2 = true;
8335 }
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8339
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8345 }
8346 {
8347 if (temp2)
8348 delete arg2;
8349 }
8350 return resultobj;
8351 fail:
8352 {
8353 if (temp2)
8354 delete arg2;
8355 }
8356 return NULL;
8357 }
8358
8359
8360 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj;
8362 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8363 wxFileSystem *arg2 = 0 ;
8364 wxString *arg3 = 0 ;
8365 wxFSFile *result;
8366 bool temp3 = false ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 PyObject * obj2 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self",(char *) "fs",(char *) "location", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8379 if (SWIG_arg_fail(2)) SWIG_fail;
8380 if (arg2 == NULL) {
8381 SWIG_null_ref("wxFileSystem");
8382 }
8383 if (SWIG_arg_fail(2)) SWIG_fail;
8384 }
8385 {
8386 arg3 = wxString_in_helper(obj2);
8387 if (arg3 == NULL) SWIG_fail;
8388 temp3 = true;
8389 }
8390 {
8391 PyThreadState* __tstate = wxPyBeginAllowThreads();
8392 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8393
8394 wxPyEndAllowThreads(__tstate);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 {
8398 resultobj = wxPyMake_wxObject(result, 1);
8399 }
8400 {
8401 if (temp3)
8402 delete arg3;
8403 }
8404 return resultobj;
8405 fail:
8406 {
8407 if (temp3)
8408 delete arg3;
8409 }
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8417 wxString *arg2 = 0 ;
8418 int arg3 = (int) 0 ;
8419 wxString result;
8420 bool temp2 = false ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 PyObject * obj2 = 0 ;
8424 char *kwnames[] = {
8425 (char *) "self",(char *) "spec",(char *) "flags", NULL
8426 };
8427
8428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8430 if (SWIG_arg_fail(1)) SWIG_fail;
8431 {
8432 arg2 = wxString_in_helper(obj1);
8433 if (arg2 == NULL) SWIG_fail;
8434 temp2 = true;
8435 }
8436 if (obj2) {
8437 {
8438 arg3 = (int)(SWIG_As_int(obj2));
8439 if (SWIG_arg_fail(3)) SWIG_fail;
8440 }
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8445
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 {
8450 #if wxUSE_UNICODE
8451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8452 #else
8453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8454 #endif
8455 }
8456 {
8457 if (temp2)
8458 delete arg2;
8459 }
8460 return resultobj;
8461 fail:
8462 {
8463 if (temp2)
8464 delete arg2;
8465 }
8466 return NULL;
8467 }
8468
8469
8470 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8471 PyObject *resultobj;
8472 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8473 wxString result;
8474 PyObject * obj0 = 0 ;
8475 char *kwnames[] = {
8476 (char *) "self", NULL
8477 };
8478
8479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 result = (arg1)->FindNext();
8485
8486 wxPyEndAllowThreads(__tstate);
8487 if (PyErr_Occurred()) SWIG_fail;
8488 }
8489 {
8490 #if wxUSE_UNICODE
8491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8492 #else
8493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8494 #endif
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj;
8504 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8505 wxString *arg2 = 0 ;
8506 wxString result;
8507 bool temp2 = false ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 char *kwnames[] = {
8511 (char *) "self",(char *) "location", NULL
8512 };
8513
8514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8516 if (SWIG_arg_fail(1)) SWIG_fail;
8517 {
8518 arg2 = wxString_in_helper(obj1);
8519 if (arg2 == NULL) SWIG_fail;
8520 temp2 = true;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 result = (arg1)->GetProtocol((wxString const &)*arg2);
8525
8526 wxPyEndAllowThreads(__tstate);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 {
8530 #if wxUSE_UNICODE
8531 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8532 #else
8533 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8534 #endif
8535 }
8536 {
8537 if (temp2)
8538 delete arg2;
8539 }
8540 return resultobj;
8541 fail:
8542 {
8543 if (temp2)
8544 delete arg2;
8545 }
8546 return NULL;
8547 }
8548
8549
8550 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8551 PyObject *resultobj;
8552 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8553 wxString *arg2 = 0 ;
8554 wxString result;
8555 bool temp2 = false ;
8556 PyObject * obj0 = 0 ;
8557 PyObject * obj1 = 0 ;
8558 char *kwnames[] = {
8559 (char *) "self",(char *) "location", NULL
8560 };
8561
8562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8564 if (SWIG_arg_fail(1)) SWIG_fail;
8565 {
8566 arg2 = wxString_in_helper(obj1);
8567 if (arg2 == NULL) SWIG_fail;
8568 temp2 = true;
8569 }
8570 {
8571 PyThreadState* __tstate = wxPyBeginAllowThreads();
8572 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8573
8574 wxPyEndAllowThreads(__tstate);
8575 if (PyErr_Occurred()) SWIG_fail;
8576 }
8577 {
8578 #if wxUSE_UNICODE
8579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8580 #else
8581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8582 #endif
8583 }
8584 {
8585 if (temp2)
8586 delete arg2;
8587 }
8588 return resultobj;
8589 fail:
8590 {
8591 if (temp2)
8592 delete arg2;
8593 }
8594 return NULL;
8595 }
8596
8597
8598 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj;
8600 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8601 wxString *arg2 = 0 ;
8602 wxString result;
8603 bool temp2 = false ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char *kwnames[] = {
8607 (char *) "self",(char *) "location", NULL
8608 };
8609
8610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8612 if (SWIG_arg_fail(1)) SWIG_fail;
8613 {
8614 arg2 = wxString_in_helper(obj1);
8615 if (arg2 == NULL) SWIG_fail;
8616 temp2 = true;
8617 }
8618 {
8619 PyThreadState* __tstate = wxPyBeginAllowThreads();
8620 result = (arg1)->GetAnchor((wxString const &)*arg2);
8621
8622 wxPyEndAllowThreads(__tstate);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 {
8626 #if wxUSE_UNICODE
8627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8628 #else
8629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8630 #endif
8631 }
8632 {
8633 if (temp2)
8634 delete arg2;
8635 }
8636 return resultobj;
8637 fail:
8638 {
8639 if (temp2)
8640 delete arg2;
8641 }
8642 return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj;
8648 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8649 wxString *arg2 = 0 ;
8650 wxString result;
8651 bool temp2 = false ;
8652 PyObject * obj0 = 0 ;
8653 PyObject * obj1 = 0 ;
8654 char *kwnames[] = {
8655 (char *) "self",(char *) "location", NULL
8656 };
8657
8658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8660 if (SWIG_arg_fail(1)) SWIG_fail;
8661 {
8662 arg2 = wxString_in_helper(obj1);
8663 if (arg2 == NULL) SWIG_fail;
8664 temp2 = true;
8665 }
8666 {
8667 PyThreadState* __tstate = wxPyBeginAllowThreads();
8668 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8669
8670 wxPyEndAllowThreads(__tstate);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 {
8674 #if wxUSE_UNICODE
8675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8676 #else
8677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8678 #endif
8679 }
8680 {
8681 if (temp2)
8682 delete arg2;
8683 }
8684 return resultobj;
8685 fail:
8686 {
8687 if (temp2)
8688 delete arg2;
8689 }
8690 return NULL;
8691 }
8692
8693
8694 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj;
8696 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8697 wxString *arg2 = 0 ;
8698 wxString result;
8699 bool temp2 = false ;
8700 PyObject * obj0 = 0 ;
8701 PyObject * obj1 = 0 ;
8702 char *kwnames[] = {
8703 (char *) "self",(char *) "location", NULL
8704 };
8705
8706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8708 if (SWIG_arg_fail(1)) SWIG_fail;
8709 {
8710 arg2 = wxString_in_helper(obj1);
8711 if (arg2 == NULL) SWIG_fail;
8712 temp2 = true;
8713 }
8714 {
8715 PyThreadState* __tstate = wxPyBeginAllowThreads();
8716 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8717
8718 wxPyEndAllowThreads(__tstate);
8719 if (PyErr_Occurred()) SWIG_fail;
8720 }
8721 {
8722 #if wxUSE_UNICODE
8723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8724 #else
8725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8726 #endif
8727 }
8728 {
8729 if (temp2)
8730 delete arg2;
8731 }
8732 return resultobj;
8733 fail:
8734 {
8735 if (temp2)
8736 delete arg2;
8737 }
8738 return NULL;
8739 }
8740
8741
8742 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8743 PyObject *obj;
8744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8745 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8746 Py_INCREF(obj);
8747 return Py_BuildValue((char *)"");
8748 }
8749 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj;
8751 wxFileSystem *result;
8752 char *kwnames[] = {
8753 NULL
8754 };
8755
8756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 result = (wxFileSystem *)new wxFileSystem();
8760
8761 wxPyEndAllowThreads(__tstate);
8762 if (PyErr_Occurred()) SWIG_fail;
8763 }
8764 {
8765 resultobj = wxPyMake_wxObject(result, 1);
8766 }
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8774 PyObject *resultobj;
8775 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8776 PyObject * obj0 = 0 ;
8777 char *kwnames[] = {
8778 (char *) "self", NULL
8779 };
8780
8781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8783 if (SWIG_arg_fail(1)) SWIG_fail;
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 delete arg1;
8787
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 Py_INCREF(Py_None); resultobj = Py_None;
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8799 PyObject *resultobj;
8800 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8801 wxString *arg2 = 0 ;
8802 bool arg3 = (bool) false ;
8803 bool temp2 = false ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 PyObject * obj2 = 0 ;
8807 char *kwnames[] = {
8808 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8809 };
8810
8811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8813 if (SWIG_arg_fail(1)) SWIG_fail;
8814 {
8815 arg2 = wxString_in_helper(obj1);
8816 if (arg2 == NULL) SWIG_fail;
8817 temp2 = true;
8818 }
8819 if (obj2) {
8820 {
8821 arg3 = (bool)(SWIG_As_bool(obj2));
8822 if (SWIG_arg_fail(3)) SWIG_fail;
8823 }
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8828
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 Py_INCREF(Py_None); resultobj = Py_None;
8833 {
8834 if (temp2)
8835 delete arg2;
8836 }
8837 return resultobj;
8838 fail:
8839 {
8840 if (temp2)
8841 delete arg2;
8842 }
8843 return NULL;
8844 }
8845
8846
8847 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj;
8849 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8850 wxString result;
8851 PyObject * obj0 = 0 ;
8852 char *kwnames[] = {
8853 (char *) "self", NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8858 if (SWIG_arg_fail(1)) SWIG_fail;
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 result = (arg1)->GetPath();
8862
8863 wxPyEndAllowThreads(__tstate);
8864 if (PyErr_Occurred()) SWIG_fail;
8865 }
8866 {
8867 #if wxUSE_UNICODE
8868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8869 #else
8870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8871 #endif
8872 }
8873 return resultobj;
8874 fail:
8875 return NULL;
8876 }
8877
8878
8879 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8880 PyObject *resultobj;
8881 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8882 wxString *arg2 = 0 ;
8883 wxFSFile *result;
8884 bool temp2 = false ;
8885 PyObject * obj0 = 0 ;
8886 PyObject * obj1 = 0 ;
8887 char *kwnames[] = {
8888 (char *) "self",(char *) "location", NULL
8889 };
8890
8891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8893 if (SWIG_arg_fail(1)) SWIG_fail;
8894 {
8895 arg2 = wxString_in_helper(obj1);
8896 if (arg2 == NULL) SWIG_fail;
8897 temp2 = true;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8902
8903 wxPyEndAllowThreads(__tstate);
8904 if (PyErr_Occurred()) SWIG_fail;
8905 }
8906 {
8907 resultobj = wxPyMake_wxObject(result, 1);
8908 }
8909 {
8910 if (temp2)
8911 delete arg2;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp2)
8917 delete arg2;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8926 wxString *arg2 = 0 ;
8927 int arg3 = (int) 0 ;
8928 wxString result;
8929 bool temp2 = false ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 PyObject * obj2 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "self",(char *) "spec",(char *) "flags", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 {
8941 arg2 = wxString_in_helper(obj1);
8942 if (arg2 == NULL) SWIG_fail;
8943 temp2 = true;
8944 }
8945 if (obj2) {
8946 {
8947 arg3 = (int)(SWIG_As_int(obj2));
8948 if (SWIG_arg_fail(3)) SWIG_fail;
8949 }
8950 }
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 {
8959 #if wxUSE_UNICODE
8960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8961 #else
8962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8963 #endif
8964 }
8965 {
8966 if (temp2)
8967 delete arg2;
8968 }
8969 return resultobj;
8970 fail:
8971 {
8972 if (temp2)
8973 delete arg2;
8974 }
8975 return NULL;
8976 }
8977
8978
8979 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8980 PyObject *resultobj;
8981 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8982 wxString result;
8983 PyObject * obj0 = 0 ;
8984 char *kwnames[] = {
8985 (char *) "self", NULL
8986 };
8987
8988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8990 if (SWIG_arg_fail(1)) SWIG_fail;
8991 {
8992 PyThreadState* __tstate = wxPyBeginAllowThreads();
8993 result = (arg1)->FindNext();
8994
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 {
8999 #if wxUSE_UNICODE
9000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9001 #else
9002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9003 #endif
9004 }
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9012 PyObject *resultobj;
9013 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9014 PyObject * obj0 = 0 ;
9015 char *kwnames[] = {
9016 (char *) "handler", NULL
9017 };
9018
9019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9021 if (SWIG_arg_fail(1)) SWIG_fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxFileSystem::AddHandler(arg1);
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 Py_INCREF(Py_None); resultobj = Py_None;
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 char *kwnames[] = {
9039 NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 wxFileSystem::CleanUpHandlers();
9046
9047 wxPyEndAllowThreads(__tstate);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 Py_INCREF(Py_None); resultobj = Py_None;
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9058 PyObject *resultobj;
9059 wxString *arg1 = 0 ;
9060 wxString result;
9061 bool temp1 = false ;
9062 PyObject * obj0 = 0 ;
9063 char *kwnames[] = {
9064 (char *) "filename", NULL
9065 };
9066
9067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9068 {
9069 arg1 = wxString_in_helper(obj0);
9070 if (arg1 == NULL) SWIG_fail;
9071 temp1 = true;
9072 }
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 {
9081 #if wxUSE_UNICODE
9082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9083 #else
9084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9085 #endif
9086 }
9087 {
9088 if (temp1)
9089 delete arg1;
9090 }
9091 return resultobj;
9092 fail:
9093 {
9094 if (temp1)
9095 delete arg1;
9096 }
9097 return NULL;
9098 }
9099
9100
9101 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj;
9103 wxString *arg1 = 0 ;
9104 wxString result;
9105 bool temp1 = false ;
9106 PyObject * obj0 = 0 ;
9107 char *kwnames[] = {
9108 (char *) "url", NULL
9109 };
9110
9111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9112 {
9113 arg1 = wxString_in_helper(obj0);
9114 if (arg1 == NULL) SWIG_fail;
9115 temp1 = true;
9116 }
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 result = FileSystem_URLToFileName((wxString const &)*arg1);
9120
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 {
9125 #if wxUSE_UNICODE
9126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9127 #else
9128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9129 #endif
9130 }
9131 {
9132 if (temp1)
9133 delete arg1;
9134 }
9135 return resultobj;
9136 fail:
9137 {
9138 if (temp1)
9139 delete arg1;
9140 }
9141 return NULL;
9142 }
9143
9144
9145 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9146 PyObject *obj;
9147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9148 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9149 Py_INCREF(obj);
9150 return Py_BuildValue((char *)"");
9151 }
9152 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9153 PyObject *resultobj;
9154 wxInternetFSHandler *result;
9155 char *kwnames[] = {
9156 NULL
9157 };
9158
9159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9177 wxString *arg2 = 0 ;
9178 bool result;
9179 bool temp2 = false ;
9180 PyObject * obj0 = 0 ;
9181 PyObject * obj1 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "self",(char *) "location", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9188 if (SWIG_arg_fail(1)) SWIG_fail;
9189 {
9190 arg2 = wxString_in_helper(obj1);
9191 if (arg2 == NULL) SWIG_fail;
9192 temp2 = true;
9193 }
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9197
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 {
9202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9203 }
9204 {
9205 if (temp2)
9206 delete arg2;
9207 }
9208 return resultobj;
9209 fail:
9210 {
9211 if (temp2)
9212 delete arg2;
9213 }
9214 return NULL;
9215 }
9216
9217
9218 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9219 PyObject *resultobj;
9220 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9221 wxFileSystem *arg2 = 0 ;
9222 wxString *arg3 = 0 ;
9223 wxFSFile *result;
9224 bool temp3 = false ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 PyObject * obj2 = 0 ;
9228 char *kwnames[] = {
9229 (char *) "self",(char *) "fs",(char *) "location", NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9234 if (SWIG_arg_fail(1)) SWIG_fail;
9235 {
9236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9237 if (SWIG_arg_fail(2)) SWIG_fail;
9238 if (arg2 == NULL) {
9239 SWIG_null_ref("wxFileSystem");
9240 }
9241 if (SWIG_arg_fail(2)) SWIG_fail;
9242 }
9243 {
9244 arg3 = wxString_in_helper(obj2);
9245 if (arg3 == NULL) SWIG_fail;
9246 temp3 = true;
9247 }
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 {
9256 resultobj = wxPyMake_wxObject(result, 1);
9257 }
9258 {
9259 if (temp3)
9260 delete arg3;
9261 }
9262 return resultobj;
9263 fail:
9264 {
9265 if (temp3)
9266 delete arg3;
9267 }
9268 return NULL;
9269 }
9270
9271
9272 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9273 PyObject *obj;
9274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9275 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9276 Py_INCREF(obj);
9277 return Py_BuildValue((char *)"");
9278 }
9279 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxZipFSHandler *result;
9282 char *kwnames[] = {
9283 NULL
9284 };
9285
9286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxZipFSHandler *)new wxZipFSHandler();
9290
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9302 PyObject *resultobj;
9303 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9304 wxString *arg2 = 0 ;
9305 bool result;
9306 bool temp2 = false ;
9307 PyObject * obj0 = 0 ;
9308 PyObject * obj1 = 0 ;
9309 char *kwnames[] = {
9310 (char *) "self",(char *) "location", NULL
9311 };
9312
9313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9315 if (SWIG_arg_fail(1)) SWIG_fail;
9316 {
9317 arg2 = wxString_in_helper(obj1);
9318 if (arg2 == NULL) SWIG_fail;
9319 temp2 = true;
9320 }
9321 {
9322 PyThreadState* __tstate = wxPyBeginAllowThreads();
9323 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9324
9325 wxPyEndAllowThreads(__tstate);
9326 if (PyErr_Occurred()) SWIG_fail;
9327 }
9328 {
9329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9330 }
9331 {
9332 if (temp2)
9333 delete arg2;
9334 }
9335 return resultobj;
9336 fail:
9337 {
9338 if (temp2)
9339 delete arg2;
9340 }
9341 return NULL;
9342 }
9343
9344
9345 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9346 PyObject *resultobj;
9347 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9348 wxFileSystem *arg2 = 0 ;
9349 wxString *arg3 = 0 ;
9350 wxFSFile *result;
9351 bool temp3 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 PyObject * obj2 = 0 ;
9355 char *kwnames[] = {
9356 (char *) "self",(char *) "fs",(char *) "location", NULL
9357 };
9358
9359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9361 if (SWIG_arg_fail(1)) SWIG_fail;
9362 {
9363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9364 if (SWIG_arg_fail(2)) SWIG_fail;
9365 if (arg2 == NULL) {
9366 SWIG_null_ref("wxFileSystem");
9367 }
9368 if (SWIG_arg_fail(2)) SWIG_fail;
9369 }
9370 {
9371 arg3 = wxString_in_helper(obj2);
9372 if (arg3 == NULL) SWIG_fail;
9373 temp3 = true;
9374 }
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 {
9383 resultobj = wxPyMake_wxObject(result, 1);
9384 }
9385 {
9386 if (temp3)
9387 delete arg3;
9388 }
9389 return resultobj;
9390 fail:
9391 {
9392 if (temp3)
9393 delete arg3;
9394 }
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9402 wxString *arg2 = 0 ;
9403 int arg3 = (int) 0 ;
9404 wxString result;
9405 bool temp2 = false ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 PyObject * obj2 = 0 ;
9409 char *kwnames[] = {
9410 (char *) "self",(char *) "spec",(char *) "flags", NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9415 if (SWIG_arg_fail(1)) SWIG_fail;
9416 {
9417 arg2 = wxString_in_helper(obj1);
9418 if (arg2 == NULL) SWIG_fail;
9419 temp2 = true;
9420 }
9421 if (obj2) {
9422 {
9423 arg3 = (int)(SWIG_As_int(obj2));
9424 if (SWIG_arg_fail(3)) SWIG_fail;
9425 }
9426 }
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 {
9435 #if wxUSE_UNICODE
9436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9437 #else
9438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9439 #endif
9440 }
9441 {
9442 if (temp2)
9443 delete arg2;
9444 }
9445 return resultobj;
9446 fail:
9447 {
9448 if (temp2)
9449 delete arg2;
9450 }
9451 return NULL;
9452 }
9453
9454
9455 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9458 wxString result;
9459 PyObject * obj0 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "self", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 result = (arg1)->FindNext();
9470
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 {
9475 #if wxUSE_UNICODE
9476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9477 #else
9478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9479 #endif
9480 }
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9488 PyObject *obj;
9489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9490 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9491 Py_INCREF(obj);
9492 return Py_BuildValue((char *)"");
9493 }
9494 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj;
9496 wxString *arg1 = 0 ;
9497 wxImage *arg2 = 0 ;
9498 long arg3 ;
9499 bool temp1 = false ;
9500 PyObject * obj0 = 0 ;
9501 PyObject * obj1 = 0 ;
9502 PyObject * obj2 = 0 ;
9503 char *kwnames[] = {
9504 (char *) "filename",(char *) "image",(char *) "type", NULL
9505 };
9506
9507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9508 {
9509 arg1 = wxString_in_helper(obj0);
9510 if (arg1 == NULL) SWIG_fail;
9511 temp1 = true;
9512 }
9513 {
9514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9515 if (SWIG_arg_fail(2)) SWIG_fail;
9516 if (arg2 == NULL) {
9517 SWIG_null_ref("wxImage");
9518 }
9519 if (SWIG_arg_fail(2)) SWIG_fail;
9520 }
9521 {
9522 arg3 = (long)(SWIG_As_long(obj2));
9523 if (SWIG_arg_fail(3)) SWIG_fail;
9524 }
9525 {
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9528
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 Py_INCREF(Py_None); resultobj = Py_None;
9533 {
9534 if (temp1)
9535 delete arg1;
9536 }
9537 return resultobj;
9538 fail:
9539 {
9540 if (temp1)
9541 delete arg1;
9542 }
9543 return NULL;
9544 }
9545
9546
9547 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj;
9549 wxString *arg1 = 0 ;
9550 wxBitmap *arg2 = 0 ;
9551 long arg3 ;
9552 bool temp1 = false ;
9553 PyObject * obj0 = 0 ;
9554 PyObject * obj1 = 0 ;
9555 PyObject * obj2 = 0 ;
9556 char *kwnames[] = {
9557 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9558 };
9559
9560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9561 {
9562 arg1 = wxString_in_helper(obj0);
9563 if (arg1 == NULL) SWIG_fail;
9564 temp1 = true;
9565 }
9566 {
9567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(2)) SWIG_fail;
9569 if (arg2 == NULL) {
9570 SWIG_null_ref("wxBitmap");
9571 }
9572 if (SWIG_arg_fail(2)) SWIG_fail;
9573 }
9574 {
9575 arg3 = (long)(SWIG_As_long(obj2));
9576 if (SWIG_arg_fail(3)) SWIG_fail;
9577 }
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9581
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 Py_INCREF(Py_None); resultobj = Py_None;
9586 {
9587 if (temp1)
9588 delete arg1;
9589 }
9590 return resultobj;
9591 fail:
9592 {
9593 if (temp1)
9594 delete arg1;
9595 }
9596 return NULL;
9597 }
9598
9599
9600 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9601 PyObject *resultobj;
9602 wxString *arg1 = 0 ;
9603 PyObject *arg2 = (PyObject *) 0 ;
9604 bool temp1 = false ;
9605 PyObject * obj0 = 0 ;
9606 PyObject * obj1 = 0 ;
9607 char *kwnames[] = {
9608 (char *) "filename",(char *) "data", NULL
9609 };
9610
9611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9612 {
9613 arg1 = wxString_in_helper(obj0);
9614 if (arg1 == NULL) SWIG_fail;
9615 temp1 = true;
9616 }
9617 arg2 = obj1;
9618 {
9619 PyThreadState* __tstate = wxPyBeginAllowThreads();
9620 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9621
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 Py_INCREF(Py_None); resultobj = Py_None;
9626 {
9627 if (temp1)
9628 delete arg1;
9629 }
9630 return resultobj;
9631 fail:
9632 {
9633 if (temp1)
9634 delete arg1;
9635 }
9636 return NULL;
9637 }
9638
9639
9640 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9641 PyObject *resultobj;
9642 wxMemoryFSHandler *result;
9643 char *kwnames[] = {
9644 NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9656 return resultobj;
9657 fail:
9658 return NULL;
9659 }
9660
9661
9662 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9663 PyObject *resultobj;
9664 wxString *arg1 = 0 ;
9665 bool temp1 = false ;
9666 PyObject * obj0 = 0 ;
9667 char *kwnames[] = {
9668 (char *) "filename", NULL
9669 };
9670
9671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9672 {
9673 arg1 = wxString_in_helper(obj0);
9674 if (arg1 == NULL) SWIG_fail;
9675 temp1 = true;
9676 }
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9680
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 Py_INCREF(Py_None); resultobj = Py_None;
9685 {
9686 if (temp1)
9687 delete arg1;
9688 }
9689 return resultobj;
9690 fail:
9691 {
9692 if (temp1)
9693 delete arg1;
9694 }
9695 return NULL;
9696 }
9697
9698
9699 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9700 PyObject *resultobj;
9701 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9702 wxString *arg2 = 0 ;
9703 bool result;
9704 bool temp2 = false ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "self",(char *) "location", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(1)) SWIG_fail;
9714 {
9715 arg2 = wxString_in_helper(obj1);
9716 if (arg2 == NULL) SWIG_fail;
9717 temp2 = true;
9718 }
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9722
9723 wxPyEndAllowThreads(__tstate);
9724 if (PyErr_Occurred()) SWIG_fail;
9725 }
9726 {
9727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9728 }
9729 {
9730 if (temp2)
9731 delete arg2;
9732 }
9733 return resultobj;
9734 fail:
9735 {
9736 if (temp2)
9737 delete arg2;
9738 }
9739 return NULL;
9740 }
9741
9742
9743 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj;
9745 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9746 wxFileSystem *arg2 = 0 ;
9747 wxString *arg3 = 0 ;
9748 wxFSFile *result;
9749 bool temp3 = false ;
9750 PyObject * obj0 = 0 ;
9751 PyObject * obj1 = 0 ;
9752 PyObject * obj2 = 0 ;
9753 char *kwnames[] = {
9754 (char *) "self",(char *) "fs",(char *) "location", NULL
9755 };
9756
9757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 {
9761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9762 if (SWIG_arg_fail(2)) SWIG_fail;
9763 if (arg2 == NULL) {
9764 SWIG_null_ref("wxFileSystem");
9765 }
9766 if (SWIG_arg_fail(2)) SWIG_fail;
9767 }
9768 {
9769 arg3 = wxString_in_helper(obj2);
9770 if (arg3 == NULL) SWIG_fail;
9771 temp3 = true;
9772 }
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9776
9777 wxPyEndAllowThreads(__tstate);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 {
9781 resultobj = wxPyMake_wxObject(result, 1);
9782 }
9783 {
9784 if (temp3)
9785 delete arg3;
9786 }
9787 return resultobj;
9788 fail:
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj;
9799 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9800 wxString *arg2 = 0 ;
9801 int arg3 = (int) 0 ;
9802 wxString result;
9803 bool temp2 = false ;
9804 PyObject * obj0 = 0 ;
9805 PyObject * obj1 = 0 ;
9806 PyObject * obj2 = 0 ;
9807 char *kwnames[] = {
9808 (char *) "self",(char *) "spec",(char *) "flags", NULL
9809 };
9810
9811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9813 if (SWIG_arg_fail(1)) SWIG_fail;
9814 {
9815 arg2 = wxString_in_helper(obj1);
9816 if (arg2 == NULL) SWIG_fail;
9817 temp2 = true;
9818 }
9819 if (obj2) {
9820 {
9821 arg3 = (int)(SWIG_As_int(obj2));
9822 if (SWIG_arg_fail(3)) SWIG_fail;
9823 }
9824 }
9825 {
9826 PyThreadState* __tstate = wxPyBeginAllowThreads();
9827 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9828
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 {
9833 #if wxUSE_UNICODE
9834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9835 #else
9836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9837 #endif
9838 }
9839 {
9840 if (temp2)
9841 delete arg2;
9842 }
9843 return resultobj;
9844 fail:
9845 {
9846 if (temp2)
9847 delete arg2;
9848 }
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9856 wxString result;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (arg1)->FindNext();
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 {
9873 #if wxUSE_UNICODE
9874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9875 #else
9876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9877 #endif
9878 }
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9886 PyObject *obj;
9887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9888 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9889 Py_INCREF(obj);
9890 return Py_BuildValue((char *)"");
9891 }
9892 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj;
9894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9895 wxString result;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (arg1)->GetName();
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 {
9912 #if wxUSE_UNICODE
9913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9914 #else
9915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9916 #endif
9917 }
9918 return resultobj;
9919 fail:
9920 return NULL;
9921 }
9922
9923
9924 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj;
9926 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9927 wxString result;
9928 PyObject * obj0 = 0 ;
9929 char *kwnames[] = {
9930 (char *) "self", NULL
9931 };
9932
9933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9935 if (SWIG_arg_fail(1)) SWIG_fail;
9936 {
9937 PyThreadState* __tstate = wxPyBeginAllowThreads();
9938 result = (arg1)->GetExtension();
9939
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 {
9944 #if wxUSE_UNICODE
9945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9946 #else
9947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9948 #endif
9949 }
9950 return resultobj;
9951 fail:
9952 return NULL;
9953 }
9954
9955
9956 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9957 PyObject *resultobj;
9958 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9959 long result;
9960 PyObject * obj0 = 0 ;
9961 char *kwnames[] = {
9962 (char *) "self", NULL
9963 };
9964
9965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9967 if (SWIG_arg_fail(1)) SWIG_fail;
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (long)(arg1)->GetType();
9971
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 resultobj = SWIG_From_long((long)(result));
9977 }
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9987 wxString result;
9988 PyObject * obj0 = 0 ;
9989 char *kwnames[] = {
9990 (char *) "self", NULL
9991 };
9992
9993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9995 if (SWIG_arg_fail(1)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (arg1)->GetMimeType();
9999
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 {
10004 #if wxUSE_UNICODE
10005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10006 #else
10007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10008 #endif
10009 }
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10017 PyObject *resultobj;
10018 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10019 wxString *arg2 = 0 ;
10020 bool result;
10021 bool temp2 = false ;
10022 PyObject * obj0 = 0 ;
10023 PyObject * obj1 = 0 ;
10024 char *kwnames[] = {
10025 (char *) "self",(char *) "name", NULL
10026 };
10027
10028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10030 if (SWIG_arg_fail(1)) SWIG_fail;
10031 {
10032 arg2 = wxString_in_helper(obj1);
10033 if (arg2 == NULL) SWIG_fail;
10034 temp2 = true;
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10039
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 {
10044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10045 }
10046 {
10047 if (temp2)
10048 delete arg2;
10049 }
10050 return resultobj;
10051 fail:
10052 {
10053 if (temp2)
10054 delete arg2;
10055 }
10056 return NULL;
10057 }
10058
10059
10060 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10061 PyObject *resultobj;
10062 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10063 wxString *arg2 = 0 ;
10064 bool temp2 = false ;
10065 PyObject * obj0 = 0 ;
10066 PyObject * obj1 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "self",(char *) "name", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 {
10075 arg2 = wxString_in_helper(obj1);
10076 if (arg2 == NULL) SWIG_fail;
10077 temp2 = true;
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 (arg1)->SetName((wxString const &)*arg2);
10082
10083 wxPyEndAllowThreads(__tstate);
10084 if (PyErr_Occurred()) SWIG_fail;
10085 }
10086 Py_INCREF(Py_None); resultobj = Py_None;
10087 {
10088 if (temp2)
10089 delete arg2;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp2)
10095 delete arg2;
10096 }
10097 return NULL;
10098 }
10099
10100
10101 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10102 PyObject *resultobj;
10103 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10104 wxString *arg2 = 0 ;
10105 bool temp2 = false ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char *kwnames[] = {
10109 (char *) "self",(char *) "extension", NULL
10110 };
10111
10112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10114 if (SWIG_arg_fail(1)) SWIG_fail;
10115 {
10116 arg2 = wxString_in_helper(obj1);
10117 if (arg2 == NULL) SWIG_fail;
10118 temp2 = true;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 (arg1)->SetExtension((wxString const &)*arg2);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 {
10129 if (temp2)
10130 delete arg2;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10145 long arg2 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char *kwnames[] = {
10149 (char *) "self",(char *) "type", NULL
10150 };
10151
10152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10154 if (SWIG_arg_fail(1)) SWIG_fail;
10155 {
10156 arg2 = (long)(SWIG_As_long(obj1));
10157 if (SWIG_arg_fail(2)) SWIG_fail;
10158 }
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 (arg1)->SetType(arg2);
10162
10163 wxPyEndAllowThreads(__tstate);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 Py_INCREF(Py_None); resultobj = Py_None;
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj;
10175 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10176 wxString *arg2 = 0 ;
10177 bool temp2 = false ;
10178 PyObject * obj0 = 0 ;
10179 PyObject * obj1 = 0 ;
10180 char *kwnames[] = {
10181 (char *) "self",(char *) "mimetype", NULL
10182 };
10183
10184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10186 if (SWIG_arg_fail(1)) SWIG_fail;
10187 {
10188 arg2 = wxString_in_helper(obj1);
10189 if (arg2 == NULL) SWIG_fail;
10190 temp2 = true;
10191 }
10192 {
10193 PyThreadState* __tstate = wxPyBeginAllowThreads();
10194 (arg1)->SetMimeType((wxString const &)*arg2);
10195
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 Py_INCREF(Py_None); resultobj = Py_None;
10200 {
10201 if (temp2)
10202 delete arg2;
10203 }
10204 return resultobj;
10205 fail:
10206 {
10207 if (temp2)
10208 delete arg2;
10209 }
10210 return NULL;
10211 }
10212
10213
10214 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10215 PyObject *obj;
10216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10217 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10218 Py_INCREF(obj);
10219 return Py_BuildValue((char *)"");
10220 }
10221 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj;
10223 wxImageHistogram *result;
10224 char *kwnames[] = {
10225 NULL
10226 };
10227
10228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (wxImageHistogram *)new wxImageHistogram();
10232
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10237 return resultobj;
10238 fail:
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 unsigned char arg1 ;
10246 unsigned char arg2 ;
10247 unsigned char arg3 ;
10248 unsigned long result;
10249 PyObject * obj0 = 0 ;
10250 PyObject * obj1 = 0 ;
10251 PyObject * obj2 = 0 ;
10252 char *kwnames[] = {
10253 (char *) "r",(char *) "g",(char *) "b", NULL
10254 };
10255
10256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10257 {
10258 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10259 if (SWIG_arg_fail(1)) SWIG_fail;
10260 }
10261 {
10262 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10263 if (SWIG_arg_fail(2)) SWIG_fail;
10264 }
10265 {
10266 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10267 if (SWIG_arg_fail(3)) SWIG_fail;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10278 }
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj;
10287 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10288 unsigned char *arg2 = (unsigned char *) 0 ;
10289 unsigned char *arg3 = (unsigned char *) 0 ;
10290 unsigned char *arg4 = (unsigned char *) 0 ;
10291 unsigned char arg5 = (unsigned char) 1 ;
10292 unsigned char arg6 = (unsigned char) 0 ;
10293 unsigned char arg7 = (unsigned char) 0 ;
10294 bool result;
10295 unsigned char temp2 ;
10296 int res2 = 0 ;
10297 unsigned char temp3 ;
10298 int res3 = 0 ;
10299 unsigned char temp4 ;
10300 int res4 = 0 ;
10301 PyObject * obj0 = 0 ;
10302 PyObject * obj1 = 0 ;
10303 PyObject * obj2 = 0 ;
10304 PyObject * obj3 = 0 ;
10305 char *kwnames[] = {
10306 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10307 };
10308
10309 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10310 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10311 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10314 if (SWIG_arg_fail(1)) SWIG_fail;
10315 if (obj1) {
10316 {
10317 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10318 if (SWIG_arg_fail(5)) SWIG_fail;
10319 }
10320 }
10321 if (obj2) {
10322 {
10323 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10324 if (SWIG_arg_fail(6)) SWIG_fail;
10325 }
10326 }
10327 if (obj3) {
10328 {
10329 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10330 if (SWIG_arg_fail(7)) SWIG_fail;
10331 }
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 {
10341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10342 }
10343 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10344 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10345 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10346 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10347 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10348 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10349 return resultobj;
10350 fail:
10351 return NULL;
10352 }
10353
10354
10355 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj;
10357 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10358 unsigned long arg2 ;
10359 unsigned long result;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char *kwnames[] = {
10363 (char *) "self",(char *) "key", NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10368 if (SWIG_arg_fail(1)) SWIG_fail;
10369 {
10370 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10371 if (SWIG_arg_fail(2)) SWIG_fail;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10390 PyObject *resultobj;
10391 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10392 unsigned char arg2 ;
10393 unsigned char arg3 ;
10394 unsigned char arg4 ;
10395 unsigned long result;
10396 PyObject * obj0 = 0 ;
10397 PyObject * obj1 = 0 ;
10398 PyObject * obj2 = 0 ;
10399 PyObject * obj3 = 0 ;
10400 char *kwnames[] = {
10401 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10402 };
10403
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 {
10408 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10409 if (SWIG_arg_fail(2)) SWIG_fail;
10410 }
10411 {
10412 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10413 if (SWIG_arg_fail(3)) SWIG_fail;
10414 }
10415 {
10416 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10417 if (SWIG_arg_fail(4)) SWIG_fail;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10422
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 {
10427 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10428 }
10429 return resultobj;
10430 fail:
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10438 wxColour *arg2 = 0 ;
10439 unsigned long result;
10440 wxColour temp2 ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "self",(char *) "colour", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10449 if (SWIG_arg_fail(1)) SWIG_fail;
10450 {
10451 arg2 = &temp2;
10452 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10453 }
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10457
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 {
10462 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10463 }
10464 return resultobj;
10465 fail:
10466 return NULL;
10467 }
10468
10469
10470 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10471 PyObject *obj;
10472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10473 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10474 Py_INCREF(obj);
10475 return Py_BuildValue((char *)"");
10476 }
10477 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10478 PyObject *resultobj;
10479 wxString *arg1 = 0 ;
10480 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10481 int arg3 = (int) -1 ;
10482 wxImage *result;
10483 bool temp1 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 PyObject * obj2 = 0 ;
10487 char *kwnames[] = {
10488 (char *) "name",(char *) "type",(char *) "index", NULL
10489 };
10490
10491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10492 {
10493 arg1 = wxString_in_helper(obj0);
10494 if (arg1 == NULL) SWIG_fail;
10495 temp1 = true;
10496 }
10497 if (obj1) {
10498 {
10499 arg2 = (long)(SWIG_As_long(obj1));
10500 if (SWIG_arg_fail(2)) SWIG_fail;
10501 }
10502 }
10503 if (obj2) {
10504 {
10505 arg3 = (int)(SWIG_As_int(obj2));
10506 if (SWIG_arg_fail(3)) SWIG_fail;
10507 }
10508 }
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10512
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10517 {
10518 if (temp1)
10519 delete arg1;
10520 }
10521 return resultobj;
10522 fail:
10523 {
10524 if (temp1)
10525 delete arg1;
10526 }
10527 return NULL;
10528 }
10529
10530
10531 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10532 PyObject *resultobj;
10533 wxImage *arg1 = (wxImage *) 0 ;
10534 PyObject * obj0 = 0 ;
10535 char *kwnames[] = {
10536 (char *) "self", NULL
10537 };
10538
10539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10541 if (SWIG_arg_fail(1)) SWIG_fail;
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 delete arg1;
10545
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 Py_INCREF(Py_None); resultobj = Py_None;
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj;
10558 wxString *arg1 = 0 ;
10559 wxString *arg2 = 0 ;
10560 int arg3 = (int) -1 ;
10561 wxImage *result;
10562 bool temp1 = false ;
10563 bool temp2 = false ;
10564 PyObject * obj0 = 0 ;
10565 PyObject * obj1 = 0 ;
10566 PyObject * obj2 = 0 ;
10567 char *kwnames[] = {
10568 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10569 };
10570
10571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10572 {
10573 arg1 = wxString_in_helper(obj0);
10574 if (arg1 == NULL) SWIG_fail;
10575 temp1 = true;
10576 }
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 if (obj2) {
10583 {
10584 arg3 = (int)(SWIG_As_int(obj2));
10585 if (SWIG_arg_fail(3)) SWIG_fail;
10586 }
10587 }
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10591
10592 wxPyEndAllowThreads(__tstate);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10596 {
10597 if (temp1)
10598 delete arg1;
10599 }
10600 {
10601 if (temp2)
10602 delete arg2;
10603 }
10604 return resultobj;
10605 fail:
10606 {
10607 if (temp1)
10608 delete arg1;
10609 }
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return NULL;
10615 }
10616
10617
10618 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj;
10620 wxInputStream *arg1 = 0 ;
10621 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10622 int arg3 = (int) -1 ;
10623 wxImage *result;
10624 wxPyInputStream *temp1 ;
10625 bool created1 ;
10626 PyObject * obj0 = 0 ;
10627 PyObject * obj1 = 0 ;
10628 PyObject * obj2 = 0 ;
10629 char *kwnames[] = {
10630 (char *) "stream",(char *) "type",(char *) "index", NULL
10631 };
10632
10633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10634 {
10635 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10636 arg1 = temp1->m_wxis;
10637 created1 = false;
10638 } else {
10639 PyErr_Clear(); // clear the failure of the wxPyConvert above
10640 arg1 = wxPyCBInputStream_create(obj0, false);
10641 if (arg1 == NULL) {
10642 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10643 SWIG_fail;
10644 }
10645 created1 = true;
10646 }
10647 }
10648 if (obj1) {
10649 {
10650 arg2 = (long)(SWIG_As_long(obj1));
10651 if (SWIG_arg_fail(2)) SWIG_fail;
10652 }
10653 }
10654 if (obj2) {
10655 {
10656 arg3 = (int)(SWIG_As_int(obj2));
10657 if (SWIG_arg_fail(3)) SWIG_fail;
10658 }
10659 }
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10663
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return resultobj;
10672 fail:
10673 {
10674 if (created1) delete arg1;
10675 }
10676 return NULL;
10677 }
10678
10679
10680 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 wxInputStream *arg1 = 0 ;
10683 wxString *arg2 = 0 ;
10684 int arg3 = (int) -1 ;
10685 wxImage *result;
10686 wxPyInputStream *temp1 ;
10687 bool created1 ;
10688 bool temp2 = false ;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char *kwnames[] = {
10693 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10694 };
10695
10696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10697 {
10698 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10699 arg1 = temp1->m_wxis;
10700 created1 = false;
10701 } else {
10702 PyErr_Clear(); // clear the failure of the wxPyConvert above
10703 arg1 = wxPyCBInputStream_create(obj0, false);
10704 if (arg1 == NULL) {
10705 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10706 SWIG_fail;
10707 }
10708 created1 = true;
10709 }
10710 }
10711 {
10712 arg2 = wxString_in_helper(obj1);
10713 if (arg2 == NULL) SWIG_fail;
10714 temp2 = true;
10715 }
10716 if (obj2) {
10717 {
10718 arg3 = (int)(SWIG_As_int(obj2));
10719 if (SWIG_arg_fail(3)) SWIG_fail;
10720 }
10721 }
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10725
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10730 {
10731 if (created1) delete arg1;
10732 }
10733 {
10734 if (temp2)
10735 delete arg2;
10736 }
10737 return resultobj;
10738 fail:
10739 {
10740 if (created1) delete arg1;
10741 }
10742 {
10743 if (temp2)
10744 delete arg2;
10745 }
10746 return NULL;
10747 }
10748
10749
10750 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj;
10752 int arg1 = (int) 0 ;
10753 int arg2 = (int) 0 ;
10754 bool arg3 = (bool) true ;
10755 wxImage *result;
10756 PyObject * obj0 = 0 ;
10757 PyObject * obj1 = 0 ;
10758 PyObject * obj2 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "width",(char *) "height",(char *) "clear", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10764 if (obj0) {
10765 {
10766 arg1 = (int)(SWIG_As_int(obj0));
10767 if (SWIG_arg_fail(1)) SWIG_fail;
10768 }
10769 }
10770 if (obj1) {
10771 {
10772 arg2 = (int)(SWIG_As_int(obj1));
10773 if (SWIG_arg_fail(2)) SWIG_fail;
10774 }
10775 }
10776 if (obj2) {
10777 {
10778 arg3 = (bool)(SWIG_As_bool(obj2));
10779 if (SWIG_arg_fail(3)) SWIG_fail;
10780 }
10781 }
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxBitmap *arg1 = 0 ;
10799 wxImage *result;
10800 PyObject * obj0 = 0 ;
10801 char *kwnames[] = {
10802 (char *) "bitmap", NULL
10803 };
10804
10805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10806 {
10807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10808 if (SWIG_arg_fail(1)) SWIG_fail;
10809 if (arg1 == NULL) {
10810 SWIG_null_ref("wxBitmap");
10811 }
10812 if (SWIG_arg_fail(1)) SWIG_fail;
10813 }
10814 {
10815 if (!wxPyCheckForApp()) SWIG_fail;
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10818
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10823 return resultobj;
10824 fail:
10825 return NULL;
10826 }
10827
10828
10829 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10830 PyObject *resultobj;
10831 int arg1 ;
10832 int arg2 ;
10833 buffer arg3 ;
10834 int arg4 ;
10835 wxImage *result;
10836 PyObject * obj0 = 0 ;
10837 PyObject * obj1 = 0 ;
10838 PyObject * obj2 = 0 ;
10839 char *kwnames[] = {
10840 (char *) "width",(char *) "height",(char *) "data", NULL
10841 };
10842
10843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10844 {
10845 arg1 = (int)(SWIG_As_int(obj0));
10846 if (SWIG_arg_fail(1)) SWIG_fail;
10847 }
10848 {
10849 arg2 = (int)(SWIG_As_int(obj1));
10850 if (SWIG_arg_fail(2)) SWIG_fail;
10851 }
10852 {
10853 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10854 }
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10858
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10870 PyObject *resultobj;
10871 int arg1 ;
10872 int arg2 ;
10873 buffer arg3 ;
10874 int arg4 ;
10875 buffer arg5 ;
10876 int arg6 ;
10877 wxImage *result;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 PyObject * obj2 = 0 ;
10881 PyObject * obj3 = 0 ;
10882 char *kwnames[] = {
10883 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10884 };
10885
10886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10887 {
10888 arg1 = (int)(SWIG_As_int(obj0));
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 }
10891 {
10892 arg2 = (int)(SWIG_As_int(obj1));
10893 if (SWIG_arg_fail(2)) SWIG_fail;
10894 }
10895 {
10896 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10897 }
10898 {
10899 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10900 }
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj;
10917 wxImage *arg1 = (wxImage *) 0 ;
10918 int arg2 ;
10919 int arg3 ;
10920 PyObject * obj0 = 0 ;
10921 PyObject * obj1 = 0 ;
10922 PyObject * obj2 = 0 ;
10923 char *kwnames[] = {
10924 (char *) "self",(char *) "width",(char *) "height", NULL
10925 };
10926
10927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10929 if (SWIG_arg_fail(1)) SWIG_fail;
10930 {
10931 arg2 = (int)(SWIG_As_int(obj1));
10932 if (SWIG_arg_fail(2)) SWIG_fail;
10933 }
10934 {
10935 arg3 = (int)(SWIG_As_int(obj2));
10936 if (SWIG_arg_fail(3)) SWIG_fail;
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->Create(arg2,arg3);
10941
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 Py_INCREF(Py_None); resultobj = Py_None;
10946 return resultobj;
10947 fail:
10948 return NULL;
10949 }
10950
10951
10952 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10953 PyObject *resultobj;
10954 wxImage *arg1 = (wxImage *) 0 ;
10955 PyObject * obj0 = 0 ;
10956 char *kwnames[] = {
10957 (char *) "self", NULL
10958 };
10959
10960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10962 if (SWIG_arg_fail(1)) SWIG_fail;
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 (arg1)->Destroy();
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 Py_INCREF(Py_None); resultobj = Py_None;
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxImage *arg1 = (wxImage *) 0 ;
10980 int arg2 ;
10981 int arg3 ;
10982 SwigValueWrapper<wxImage > result;
10983 PyObject * obj0 = 0 ;
10984 PyObject * obj1 = 0 ;
10985 PyObject * obj2 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self",(char *) "width",(char *) "height", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 arg2 = (int)(SWIG_As_int(obj1));
10995 if (SWIG_arg_fail(2)) SWIG_fail;
10996 }
10997 {
10998 arg3 = (int)(SWIG_As_int(obj2));
10999 if (SWIG_arg_fail(3)) SWIG_fail;
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (arg1)->Scale(arg2,arg3);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 {
11009 wxImage * resultptr;
11010 resultptr = new wxImage((wxImage &)(result));
11011 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11012 }
11013 return resultobj;
11014 fail:
11015 return NULL;
11016 }
11017
11018
11019 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11020 PyObject *resultobj;
11021 wxImage *arg1 = (wxImage *) 0 ;
11022 int arg2 ;
11023 int arg3 ;
11024 SwigValueWrapper<wxImage > result;
11025 PyObject * obj0 = 0 ;
11026 PyObject * obj1 = 0 ;
11027 PyObject * obj2 = 0 ;
11028 char *kwnames[] = {
11029 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11030 };
11031
11032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11034 if (SWIG_arg_fail(1)) SWIG_fail;
11035 {
11036 arg2 = (int)(SWIG_As_int(obj1));
11037 if (SWIG_arg_fail(2)) SWIG_fail;
11038 }
11039 {
11040 arg3 = (int)(SWIG_As_int(obj2));
11041 if (SWIG_arg_fail(3)) SWIG_fail;
11042 }
11043 {
11044 PyThreadState* __tstate = wxPyBeginAllowThreads();
11045 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11046
11047 wxPyEndAllowThreads(__tstate);
11048 if (PyErr_Occurred()) SWIG_fail;
11049 }
11050 {
11051 wxImage * resultptr;
11052 resultptr = new wxImage((wxImage &)(result));
11053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11054 }
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11062 PyObject *resultobj;
11063 wxImage *arg1 = (wxImage *) 0 ;
11064 int arg2 ;
11065 int arg3 ;
11066 wxImage *result;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 PyObject * obj2 = 0 ;
11070 char *kwnames[] = {
11071 (char *) "self",(char *) "width",(char *) "height", NULL
11072 };
11073
11074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11076 if (SWIG_arg_fail(1)) SWIG_fail;
11077 {
11078 arg2 = (int)(SWIG_As_int(obj1));
11079 if (SWIG_arg_fail(2)) SWIG_fail;
11080 }
11081 {
11082 arg3 = (int)(SWIG_As_int(obj2));
11083 if (SWIG_arg_fail(3)) SWIG_fail;
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 {
11088 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11089 result = (wxImage *) &_result_ref;
11090 }
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj;
11104 wxImage *arg1 = (wxImage *) 0 ;
11105 wxSize *arg2 = 0 ;
11106 wxPoint *arg3 = 0 ;
11107 int arg4 = (int) -1 ;
11108 int arg5 = (int) -1 ;
11109 int arg6 = (int) -1 ;
11110 wxImage *result;
11111 wxSize temp2 ;
11112 wxPoint temp3 ;
11113 PyObject * obj0 = 0 ;
11114 PyObject * obj1 = 0 ;
11115 PyObject * obj2 = 0 ;
11116 PyObject * obj3 = 0 ;
11117 PyObject * obj4 = 0 ;
11118 PyObject * obj5 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 arg2 = &temp2;
11128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11129 }
11130 {
11131 arg3 = &temp3;
11132 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11133 }
11134 if (obj3) {
11135 {
11136 arg4 = (int)(SWIG_As_int(obj3));
11137 if (SWIG_arg_fail(4)) SWIG_fail;
11138 }
11139 }
11140 if (obj4) {
11141 {
11142 arg5 = (int)(SWIG_As_int(obj4));
11143 if (SWIG_arg_fail(5)) SWIG_fail;
11144 }
11145 }
11146 if (obj5) {
11147 {
11148 arg6 = (int)(SWIG_As_int(obj5));
11149 if (SWIG_arg_fail(6)) SWIG_fail;
11150 }
11151 }
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 {
11155 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11156 result = (wxImage *) &_result_ref;
11157 }
11158
11159 wxPyEndAllowThreads(__tstate);
11160 if (PyErr_Occurred()) SWIG_fail;
11161 }
11162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj;
11171 wxImage *arg1 = (wxImage *) 0 ;
11172 int arg2 ;
11173 int arg3 ;
11174 unsigned char arg4 ;
11175 unsigned char arg5 ;
11176 unsigned char arg6 ;
11177 PyObject * obj0 = 0 ;
11178 PyObject * obj1 = 0 ;
11179 PyObject * obj2 = 0 ;
11180 PyObject * obj3 = 0 ;
11181 PyObject * obj4 = 0 ;
11182 PyObject * obj5 = 0 ;
11183 char *kwnames[] = {
11184 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11185 };
11186
11187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11189 if (SWIG_arg_fail(1)) SWIG_fail;
11190 {
11191 arg2 = (int)(SWIG_As_int(obj1));
11192 if (SWIG_arg_fail(2)) SWIG_fail;
11193 }
11194 {
11195 arg3 = (int)(SWIG_As_int(obj2));
11196 if (SWIG_arg_fail(3)) SWIG_fail;
11197 }
11198 {
11199 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11200 if (SWIG_arg_fail(4)) SWIG_fail;
11201 }
11202 {
11203 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11204 if (SWIG_arg_fail(5)) SWIG_fail;
11205 }
11206 {
11207 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11208 if (SWIG_arg_fail(6)) SWIG_fail;
11209 }
11210 {
11211 PyThreadState* __tstate = wxPyBeginAllowThreads();
11212 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11213
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 Py_INCREF(Py_None); resultobj = Py_None;
11218 return resultobj;
11219 fail:
11220 return NULL;
11221 }
11222
11223
11224 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj;
11226 wxImage *arg1 = (wxImage *) 0 ;
11227 wxRect *arg2 = 0 ;
11228 unsigned char arg3 ;
11229 unsigned char arg4 ;
11230 unsigned char arg5 ;
11231 wxRect temp2 ;
11232 PyObject * obj0 = 0 ;
11233 PyObject * obj1 = 0 ;
11234 PyObject * obj2 = 0 ;
11235 PyObject * obj3 = 0 ;
11236 PyObject * obj4 = 0 ;
11237 char *kwnames[] = {
11238 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11239 };
11240
11241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11243 if (SWIG_arg_fail(1)) SWIG_fail;
11244 {
11245 arg2 = &temp2;
11246 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11247 }
11248 {
11249 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11250 if (SWIG_arg_fail(3)) SWIG_fail;
11251 }
11252 {
11253 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11254 if (SWIG_arg_fail(4)) SWIG_fail;
11255 }
11256 {
11257 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11258 if (SWIG_arg_fail(5)) SWIG_fail;
11259 }
11260 {
11261 PyThreadState* __tstate = wxPyBeginAllowThreads();
11262 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11263
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 Py_INCREF(Py_None); resultobj = Py_None;
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11275 PyObject *resultobj;
11276 wxImage *arg1 = (wxImage *) 0 ;
11277 int arg2 ;
11278 int arg3 ;
11279 unsigned char result;
11280 PyObject * obj0 = 0 ;
11281 PyObject * obj1 = 0 ;
11282 PyObject * obj2 = 0 ;
11283 char *kwnames[] = {
11284 (char *) "self",(char *) "x",(char *) "y", NULL
11285 };
11286
11287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11289 if (SWIG_arg_fail(1)) SWIG_fail;
11290 {
11291 arg2 = (int)(SWIG_As_int(obj1));
11292 if (SWIG_arg_fail(2)) SWIG_fail;
11293 }
11294 {
11295 arg3 = (int)(SWIG_As_int(obj2));
11296 if (SWIG_arg_fail(3)) SWIG_fail;
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 {
11306 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11307 }
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj;
11316 wxImage *arg1 = (wxImage *) 0 ;
11317 int arg2 ;
11318 int arg3 ;
11319 unsigned char result;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 PyObject * obj2 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "self",(char *) "x",(char *) "y", NULL
11325 };
11326
11327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11329 if (SWIG_arg_fail(1)) SWIG_fail;
11330 {
11331 arg2 = (int)(SWIG_As_int(obj1));
11332 if (SWIG_arg_fail(2)) SWIG_fail;
11333 }
11334 {
11335 arg3 = (int)(SWIG_As_int(obj2));
11336 if (SWIG_arg_fail(3)) SWIG_fail;
11337 }
11338 {
11339 PyThreadState* __tstate = wxPyBeginAllowThreads();
11340 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11341
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 {
11346 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11347 }
11348 return resultobj;
11349 fail:
11350 return NULL;
11351 }
11352
11353
11354 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11355 PyObject *resultobj;
11356 wxImage *arg1 = (wxImage *) 0 ;
11357 int arg2 ;
11358 int arg3 ;
11359 unsigned char result;
11360 PyObject * obj0 = 0 ;
11361 PyObject * obj1 = 0 ;
11362 PyObject * obj2 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "self",(char *) "x",(char *) "y", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11369 if (SWIG_arg_fail(1)) SWIG_fail;
11370 {
11371 arg2 = (int)(SWIG_As_int(obj1));
11372 if (SWIG_arg_fail(2)) SWIG_fail;
11373 }
11374 {
11375 arg3 = (int)(SWIG_As_int(obj2));
11376 if (SWIG_arg_fail(3)) SWIG_fail;
11377 }
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11381
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 {
11386 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11387 }
11388 return resultobj;
11389 fail:
11390 return NULL;
11391 }
11392
11393
11394 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11395 PyObject *resultobj;
11396 wxImage *arg1 = (wxImage *) 0 ;
11397 int arg2 ;
11398 int arg3 ;
11399 unsigned char arg4 ;
11400 PyObject * obj0 = 0 ;
11401 PyObject * obj1 = 0 ;
11402 PyObject * obj2 = 0 ;
11403 PyObject * obj3 = 0 ;
11404 char *kwnames[] = {
11405 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11406 };
11407
11408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
11413 if (SWIG_arg_fail(2)) SWIG_fail;
11414 }
11415 {
11416 arg3 = (int)(SWIG_As_int(obj2));
11417 if (SWIG_arg_fail(3)) SWIG_fail;
11418 }
11419 {
11420 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11421 if (SWIG_arg_fail(4)) SWIG_fail;
11422 }
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 (arg1)->SetAlpha(arg2,arg3,arg4);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 Py_INCREF(Py_None); resultobj = Py_None;
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj;
11439 wxImage *arg1 = (wxImage *) 0 ;
11440 int arg2 ;
11441 int arg3 ;
11442 unsigned char result;
11443 PyObject * obj0 = 0 ;
11444 PyObject * obj1 = 0 ;
11445 PyObject * obj2 = 0 ;
11446 char *kwnames[] = {
11447 (char *) "self",(char *) "x",(char *) "y", NULL
11448 };
11449
11450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 {
11454 arg2 = (int)(SWIG_As_int(obj1));
11455 if (SWIG_arg_fail(2)) SWIG_fail;
11456 }
11457 {
11458 arg3 = (int)(SWIG_As_int(obj2));
11459 if (SWIG_arg_fail(3)) SWIG_fail;
11460 }
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11464
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 {
11469 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11470 }
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj;
11479 wxImage *arg1 = (wxImage *) 0 ;
11480 bool result;
11481 PyObject * obj0 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "self", NULL
11484 };
11485
11486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11488 if (SWIG_arg_fail(1)) SWIG_fail;
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)(arg1)->HasAlpha();
11492
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11498 }
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxImage *arg1 = (wxImage *) 0 ;
11508 PyObject * obj0 = 0 ;
11509 char *kwnames[] = {
11510 (char *) "self", NULL
11511 };
11512
11513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11515 if (SWIG_arg_fail(1)) SWIG_fail;
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 (arg1)->InitAlpha();
11519
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 Py_INCREF(Py_None); resultobj = Py_None;
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj;
11532 wxImage *arg1 = (wxImage *) 0 ;
11533 int arg2 ;
11534 int arg3 ;
11535 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11536 bool result;
11537 PyObject * obj0 = 0 ;
11538 PyObject * obj1 = 0 ;
11539 PyObject * obj2 = 0 ;
11540 PyObject * obj3 = 0 ;
11541 char *kwnames[] = {
11542 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11543 };
11544
11545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11547 if (SWIG_arg_fail(1)) SWIG_fail;
11548 {
11549 arg2 = (int)(SWIG_As_int(obj1));
11550 if (SWIG_arg_fail(2)) SWIG_fail;
11551 }
11552 {
11553 arg3 = (int)(SWIG_As_int(obj2));
11554 if (SWIG_arg_fail(3)) SWIG_fail;
11555 }
11556 if (obj3) {
11557 {
11558 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11559 if (SWIG_arg_fail(4)) SWIG_fail;
11560 }
11561 }
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11565
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 {
11570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11571 }
11572 return resultobj;
11573 fail:
11574 return NULL;
11575 }
11576
11577
11578 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11579 PyObject *resultobj;
11580 wxImage *arg1 = (wxImage *) 0 ;
11581 byte *arg2 = (byte *) 0 ;
11582 byte *arg3 = (byte *) 0 ;
11583 byte *arg4 = (byte *) 0 ;
11584 byte arg5 = (byte) 0 ;
11585 byte arg6 = (byte) 0 ;
11586 byte arg7 = (byte) 0 ;
11587 bool result;
11588 byte temp2 ;
11589 int res2 = 0 ;
11590 byte temp3 ;
11591 int res3 = 0 ;
11592 byte temp4 ;
11593 int res4 = 0 ;
11594 PyObject * obj0 = 0 ;
11595 PyObject * obj1 = 0 ;
11596 PyObject * obj2 = 0 ;
11597 PyObject * obj3 = 0 ;
11598 char *kwnames[] = {
11599 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11600 };
11601
11602 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11603 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11604 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11607 if (SWIG_arg_fail(1)) SWIG_fail;
11608 if (obj1) {
11609 {
11610 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11611 if (SWIG_arg_fail(5)) SWIG_fail;
11612 }
11613 }
11614 if (obj2) {
11615 {
11616 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11617 if (SWIG_arg_fail(6)) SWIG_fail;
11618 }
11619 }
11620 if (obj3) {
11621 {
11622 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11623 if (SWIG_arg_fail(7)) SWIG_fail;
11624 }
11625 }
11626 {
11627 PyThreadState* __tstate = wxPyBeginAllowThreads();
11628 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11629
11630 wxPyEndAllowThreads(__tstate);
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 {
11634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11635 }
11636 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11637 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11638 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11639 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11640 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11641 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11642 return resultobj;
11643 fail:
11644 return NULL;
11645 }
11646
11647
11648 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11649 PyObject *resultobj;
11650 wxImage *arg1 = (wxImage *) 0 ;
11651 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11652 bool result;
11653 PyObject * obj0 = 0 ;
11654 PyObject * obj1 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self",(char *) "threshold", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 if (obj1) {
11663 {
11664 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11665 if (SWIG_arg_fail(2)) SWIG_fail;
11666 }
11667 }
11668 {
11669 PyThreadState* __tstate = wxPyBeginAllowThreads();
11670 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11671
11672 wxPyEndAllowThreads(__tstate);
11673 if (PyErr_Occurred()) SWIG_fail;
11674 }
11675 {
11676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677 }
11678 return resultobj;
11679 fail:
11680 return NULL;
11681 }
11682
11683
11684 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11685 PyObject *resultobj;
11686 wxImage *arg1 = (wxImage *) 0 ;
11687 unsigned char arg2 ;
11688 unsigned char arg3 ;
11689 unsigned char arg4 ;
11690 bool result;
11691 PyObject * obj0 = 0 ;
11692 PyObject * obj1 = 0 ;
11693 PyObject * obj2 = 0 ;
11694 PyObject * obj3 = 0 ;
11695 char *kwnames[] = {
11696 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11697 };
11698
11699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11701 if (SWIG_arg_fail(1)) SWIG_fail;
11702 {
11703 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11704 if (SWIG_arg_fail(2)) SWIG_fail;
11705 }
11706 {
11707 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11708 if (SWIG_arg_fail(3)) SWIG_fail;
11709 }
11710 {
11711 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11712 if (SWIG_arg_fail(4)) SWIG_fail;
11713 }
11714 {
11715 PyThreadState* __tstate = wxPyBeginAllowThreads();
11716 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11717
11718 wxPyEndAllowThreads(__tstate);
11719 if (PyErr_Occurred()) SWIG_fail;
11720 }
11721 {
11722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11723 }
11724 return resultobj;
11725 fail:
11726 return NULL;
11727 }
11728
11729
11730 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11731 PyObject *resultobj;
11732 wxImage *arg1 = (wxImage *) 0 ;
11733 wxImage *arg2 = 0 ;
11734 byte arg3 ;
11735 byte arg4 ;
11736 byte arg5 ;
11737 bool result;
11738 PyObject * obj0 = 0 ;
11739 PyObject * obj1 = 0 ;
11740 PyObject * obj2 = 0 ;
11741 PyObject * obj3 = 0 ;
11742 PyObject * obj4 = 0 ;
11743 char *kwnames[] = {
11744 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11745 };
11746
11747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11749 if (SWIG_arg_fail(1)) SWIG_fail;
11750 {
11751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11752 if (SWIG_arg_fail(2)) SWIG_fail;
11753 if (arg2 == NULL) {
11754 SWIG_null_ref("wxImage");
11755 }
11756 if (SWIG_arg_fail(2)) SWIG_fail;
11757 }
11758 {
11759 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11760 if (SWIG_arg_fail(3)) SWIG_fail;
11761 }
11762 {
11763 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11764 if (SWIG_arg_fail(4)) SWIG_fail;
11765 }
11766 {
11767 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11768 if (SWIG_arg_fail(5)) SWIG_fail;
11769 }
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11773
11774 wxPyEndAllowThreads(__tstate);
11775 if (PyErr_Occurred()) SWIG_fail;
11776 }
11777 {
11778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11779 }
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11787 PyObject *resultobj;
11788 wxString *arg1 = 0 ;
11789 bool result;
11790 bool temp1 = false ;
11791 PyObject * obj0 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "name", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11797 {
11798 arg1 = wxString_in_helper(obj0);
11799 if (arg1 == NULL) SWIG_fail;
11800 temp1 = true;
11801 }
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11805
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11811 }
11812 {
11813 if (temp1)
11814 delete arg1;
11815 }
11816 return resultobj;
11817 fail:
11818 {
11819 if (temp1)
11820 delete arg1;
11821 }
11822 return NULL;
11823 }
11824
11825
11826 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11827 PyObject *resultobj;
11828 wxString *arg1 = 0 ;
11829 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11830 int result;
11831 bool temp1 = false ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 char *kwnames[] = {
11835 (char *) "name",(char *) "type", NULL
11836 };
11837
11838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11839 {
11840 arg1 = wxString_in_helper(obj0);
11841 if (arg1 == NULL) SWIG_fail;
11842 temp1 = true;
11843 }
11844 if (obj1) {
11845 {
11846 arg2 = (long)(SWIG_As_long(obj1));
11847 if (SWIG_arg_fail(2)) SWIG_fail;
11848 }
11849 }
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11853
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = SWIG_From_int((int)(result));
11859 }
11860 {
11861 if (temp1)
11862 delete arg1;
11863 }
11864 return resultobj;
11865 fail:
11866 {
11867 if (temp1)
11868 delete arg1;
11869 }
11870 return NULL;
11871 }
11872
11873
11874 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj;
11876 wxImage *arg1 = (wxImage *) 0 ;
11877 wxString *arg2 = 0 ;
11878 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11879 int arg4 = (int) -1 ;
11880 bool result;
11881 bool temp2 = false ;
11882 PyObject * obj0 = 0 ;
11883 PyObject * obj1 = 0 ;
11884 PyObject * obj2 = 0 ;
11885 PyObject * obj3 = 0 ;
11886 char *kwnames[] = {
11887 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11892 if (SWIG_arg_fail(1)) SWIG_fail;
11893 {
11894 arg2 = wxString_in_helper(obj1);
11895 if (arg2 == NULL) SWIG_fail;
11896 temp2 = true;
11897 }
11898 if (obj2) {
11899 {
11900 arg3 = (long)(SWIG_As_long(obj2));
11901 if (SWIG_arg_fail(3)) SWIG_fail;
11902 }
11903 }
11904 if (obj3) {
11905 {
11906 arg4 = (int)(SWIG_As_int(obj3));
11907 if (SWIG_arg_fail(4)) SWIG_fail;
11908 }
11909 }
11910 {
11911 PyThreadState* __tstate = wxPyBeginAllowThreads();
11912 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11913
11914 wxPyEndAllowThreads(__tstate);
11915 if (PyErr_Occurred()) SWIG_fail;
11916 }
11917 {
11918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11919 }
11920 {
11921 if (temp2)
11922 delete arg2;
11923 }
11924 return resultobj;
11925 fail:
11926 {
11927 if (temp2)
11928 delete arg2;
11929 }
11930 return NULL;
11931 }
11932
11933
11934 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11935 PyObject *resultobj;
11936 wxImage *arg1 = (wxImage *) 0 ;
11937 wxString *arg2 = 0 ;
11938 wxString *arg3 = 0 ;
11939 int arg4 = (int) -1 ;
11940 bool result;
11941 bool temp2 = false ;
11942 bool temp3 = false ;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 PyObject * obj2 = 0 ;
11946 PyObject * obj3 = 0 ;
11947 char *kwnames[] = {
11948 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11949 };
11950
11951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11953 if (SWIG_arg_fail(1)) SWIG_fail;
11954 {
11955 arg2 = wxString_in_helper(obj1);
11956 if (arg2 == NULL) SWIG_fail;
11957 temp2 = true;
11958 }
11959 {
11960 arg3 = wxString_in_helper(obj2);
11961 if (arg3 == NULL) SWIG_fail;
11962 temp3 = true;
11963 }
11964 if (obj3) {
11965 {
11966 arg4 = (int)(SWIG_As_int(obj3));
11967 if (SWIG_arg_fail(4)) SWIG_fail;
11968 }
11969 }
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11973
11974 wxPyEndAllowThreads(__tstate);
11975 if (PyErr_Occurred()) SWIG_fail;
11976 }
11977 {
11978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11979 }
11980 {
11981 if (temp2)
11982 delete arg2;
11983 }
11984 {
11985 if (temp3)
11986 delete arg3;
11987 }
11988 return resultobj;
11989 fail:
11990 {
11991 if (temp2)
11992 delete arg2;
11993 }
11994 {
11995 if (temp3)
11996 delete arg3;
11997 }
11998 return NULL;
11999 }
12000
12001
12002 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj;
12004 wxImage *arg1 = (wxImage *) 0 ;
12005 wxString *arg2 = 0 ;
12006 int arg3 ;
12007 bool result;
12008 bool temp2 = false ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 PyObject * obj2 = 0 ;
12012 char *kwnames[] = {
12013 (char *) "self",(char *) "name",(char *) "type", NULL
12014 };
12015
12016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12018 if (SWIG_arg_fail(1)) SWIG_fail;
12019 {
12020 arg2 = wxString_in_helper(obj1);
12021 if (arg2 == NULL) SWIG_fail;
12022 temp2 = true;
12023 }
12024 {
12025 arg3 = (int)(SWIG_As_int(obj2));
12026 if (SWIG_arg_fail(3)) SWIG_fail;
12027 }
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12031
12032 wxPyEndAllowThreads(__tstate);
12033 if (PyErr_Occurred()) SWIG_fail;
12034 }
12035 {
12036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12037 }
12038 {
12039 if (temp2)
12040 delete arg2;
12041 }
12042 return resultobj;
12043 fail:
12044 {
12045 if (temp2)
12046 delete arg2;
12047 }
12048 return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj;
12054 wxImage *arg1 = (wxImage *) 0 ;
12055 wxString *arg2 = 0 ;
12056 wxString *arg3 = 0 ;
12057 bool result;
12058 bool temp2 = false ;
12059 bool temp3 = false ;
12060 PyObject * obj0 = 0 ;
12061 PyObject * obj1 = 0 ;
12062 PyObject * obj2 = 0 ;
12063 char *kwnames[] = {
12064 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12065 };
12066
12067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12069 if (SWIG_arg_fail(1)) SWIG_fail;
12070 {
12071 arg2 = wxString_in_helper(obj1);
12072 if (arg2 == NULL) SWIG_fail;
12073 temp2 = true;
12074 }
12075 {
12076 arg3 = wxString_in_helper(obj2);
12077 if (arg3 == NULL) SWIG_fail;
12078 temp3 = true;
12079 }
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12089 }
12090 {
12091 if (temp2)
12092 delete arg2;
12093 }
12094 {
12095 if (temp3)
12096 delete arg3;
12097 }
12098 return resultobj;
12099 fail:
12100 {
12101 if (temp2)
12102 delete arg2;
12103 }
12104 {
12105 if (temp3)
12106 delete arg3;
12107 }
12108 return NULL;
12109 }
12110
12111
12112 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12113 PyObject *resultobj;
12114 wxInputStream *arg1 = 0 ;
12115 bool result;
12116 wxPyInputStream *temp1 ;
12117 bool created1 ;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "stream", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12124 {
12125 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12126 arg1 = temp1->m_wxis;
12127 created1 = false;
12128 } else {
12129 PyErr_Clear(); // clear the failure of the wxPyConvert above
12130 arg1 = wxPyCBInputStream_create(obj0, false);
12131 if (arg1 == NULL) {
12132 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12133 SWIG_fail;
12134 }
12135 created1 = true;
12136 }
12137 }
12138 {
12139 PyThreadState* __tstate = wxPyBeginAllowThreads();
12140 result = (bool)wxImage::CanRead(*arg1);
12141
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12147 }
12148 {
12149 if (created1) delete arg1;
12150 }
12151 return resultobj;
12152 fail:
12153 {
12154 if (created1) delete arg1;
12155 }
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj;
12162 wxImage *arg1 = (wxImage *) 0 ;
12163 wxInputStream *arg2 = 0 ;
12164 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12165 int arg4 = (int) -1 ;
12166 bool result;
12167 wxPyInputStream *temp2 ;
12168 bool created2 ;
12169 PyObject * obj0 = 0 ;
12170 PyObject * obj1 = 0 ;
12171 PyObject * obj2 = 0 ;
12172 PyObject * obj3 = 0 ;
12173 char *kwnames[] = {
12174 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12175 };
12176
12177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12179 if (SWIG_arg_fail(1)) SWIG_fail;
12180 {
12181 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12182 arg2 = temp2->m_wxis;
12183 created2 = false;
12184 } else {
12185 PyErr_Clear(); // clear the failure of the wxPyConvert above
12186 arg2 = wxPyCBInputStream_create(obj1, false);
12187 if (arg2 == NULL) {
12188 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12189 SWIG_fail;
12190 }
12191 created2 = true;
12192 }
12193 }
12194 if (obj2) {
12195 {
12196 arg3 = (long)(SWIG_As_long(obj2));
12197 if (SWIG_arg_fail(3)) SWIG_fail;
12198 }
12199 }
12200 if (obj3) {
12201 {
12202 arg4 = (int)(SWIG_As_int(obj3));
12203 if (SWIG_arg_fail(4)) SWIG_fail;
12204 }
12205 }
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 {
12214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12215 }
12216 {
12217 if (created2) delete arg2;
12218 }
12219 return resultobj;
12220 fail:
12221 {
12222 if (created2) delete arg2;
12223 }
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxImage *arg1 = (wxImage *) 0 ;
12231 wxInputStream *arg2 = 0 ;
12232 wxString *arg3 = 0 ;
12233 int arg4 = (int) -1 ;
12234 bool result;
12235 wxPyInputStream *temp2 ;
12236 bool created2 ;
12237 bool temp3 = false ;
12238 PyObject * obj0 = 0 ;
12239 PyObject * obj1 = 0 ;
12240 PyObject * obj2 = 0 ;
12241 PyObject * obj3 = 0 ;
12242 char *kwnames[] = {
12243 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12244 };
12245
12246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12248 if (SWIG_arg_fail(1)) SWIG_fail;
12249 {
12250 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12251 arg2 = temp2->m_wxis;
12252 created2 = false;
12253 } else {
12254 PyErr_Clear(); // clear the failure of the wxPyConvert above
12255 arg2 = wxPyCBInputStream_create(obj1, false);
12256 if (arg2 == NULL) {
12257 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12258 SWIG_fail;
12259 }
12260 created2 = true;
12261 }
12262 }
12263 {
12264 arg3 = wxString_in_helper(obj2);
12265 if (arg3 == NULL) SWIG_fail;
12266 temp3 = true;
12267 }
12268 if (obj3) {
12269 {
12270 arg4 = (int)(SWIG_As_int(obj3));
12271 if (SWIG_arg_fail(4)) SWIG_fail;
12272 }
12273 }
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12277
12278 wxPyEndAllowThreads(__tstate);
12279 if (PyErr_Occurred()) SWIG_fail;
12280 }
12281 {
12282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12283 }
12284 {
12285 if (created2) delete arg2;
12286 }
12287 {
12288 if (temp3)
12289 delete arg3;
12290 }
12291 return resultobj;
12292 fail:
12293 {
12294 if (created2) delete arg2;
12295 }
12296 {
12297 if (temp3)
12298 delete arg3;
12299 }
12300 return NULL;
12301 }
12302
12303
12304 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12305 PyObject *resultobj;
12306 wxImage *arg1 = (wxImage *) 0 ;
12307 bool result;
12308 PyObject * obj0 = 0 ;
12309 char *kwnames[] = {
12310 (char *) "self", NULL
12311 };
12312
12313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12315 if (SWIG_arg_fail(1)) SWIG_fail;
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 result = (bool)(arg1)->Ok();
12319
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 {
12324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12325 }
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj;
12334 wxImage *arg1 = (wxImage *) 0 ;
12335 int result;
12336 PyObject * obj0 = 0 ;
12337 char *kwnames[] = {
12338 (char *) "self", NULL
12339 };
12340
12341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (int)(arg1)->GetWidth();
12347
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 {
12352 resultobj = SWIG_From_int((int)(result));
12353 }
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12361 PyObject *resultobj;
12362 wxImage *arg1 = (wxImage *) 0 ;
12363 int result;
12364 PyObject * obj0 = 0 ;
12365 char *kwnames[] = {
12366 (char *) "self", NULL
12367 };
12368
12369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12371 if (SWIG_arg_fail(1)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (int)(arg1)->GetHeight();
12375
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 {
12380 resultobj = SWIG_From_int((int)(result));
12381 }
12382 return resultobj;
12383 fail:
12384 return NULL;
12385 }
12386
12387
12388 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj;
12390 wxImage *arg1 = (wxImage *) 0 ;
12391 wxSize result;
12392 PyObject * obj0 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) 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 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = wxImage_GetSize(arg1);
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 wxSize * resultptr;
12409 resultptr = new wxSize((wxSize &)(result));
12410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12411 }
12412 return resultobj;
12413 fail:
12414 return NULL;
12415 }
12416
12417
12418 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12419 PyObject *resultobj;
12420 wxImage *arg1 = (wxImage *) 0 ;
12421 wxRect *arg2 = 0 ;
12422 SwigValueWrapper<wxImage > result;
12423 wxRect temp2 ;
12424 PyObject * obj0 = 0 ;
12425 PyObject * obj1 = 0 ;
12426 char *kwnames[] = {
12427 (char *) "self",(char *) "rect", NULL
12428 };
12429
12430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12432 if (SWIG_arg_fail(1)) SWIG_fail;
12433 {
12434 arg2 = &temp2;
12435 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12436 }
12437 {
12438 PyThreadState* __tstate = wxPyBeginAllowThreads();
12439 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12440
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 {
12445 wxImage * resultptr;
12446 resultptr = new wxImage((wxImage &)(result));
12447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12448 }
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj;
12457 wxImage *arg1 = (wxImage *) 0 ;
12458 wxSize *arg2 = 0 ;
12459 wxPoint *arg3 = 0 ;
12460 int arg4 = (int) -1 ;
12461 int arg5 = (int) -1 ;
12462 int arg6 = (int) -1 ;
12463 SwigValueWrapper<wxImage > result;
12464 wxSize temp2 ;
12465 wxPoint temp3 ;
12466 PyObject * obj0 = 0 ;
12467 PyObject * obj1 = 0 ;
12468 PyObject * obj2 = 0 ;
12469 PyObject * obj3 = 0 ;
12470 PyObject * obj4 = 0 ;
12471 PyObject * obj5 = 0 ;
12472 char *kwnames[] = {
12473 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12474 };
12475
12476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12478 if (SWIG_arg_fail(1)) SWIG_fail;
12479 {
12480 arg2 = &temp2;
12481 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12482 }
12483 {
12484 arg3 = &temp3;
12485 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12486 }
12487 if (obj3) {
12488 {
12489 arg4 = (int)(SWIG_As_int(obj3));
12490 if (SWIG_arg_fail(4)) SWIG_fail;
12491 }
12492 }
12493 if (obj4) {
12494 {
12495 arg5 = (int)(SWIG_As_int(obj4));
12496 if (SWIG_arg_fail(5)) SWIG_fail;
12497 }
12498 }
12499 if (obj5) {
12500 {
12501 arg6 = (int)(SWIG_As_int(obj5));
12502 if (SWIG_arg_fail(6)) SWIG_fail;
12503 }
12504 }
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12508
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 {
12513 wxImage * resultptr;
12514 resultptr = new wxImage((wxImage &)(result));
12515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12516 }
12517 return resultobj;
12518 fail:
12519 return NULL;
12520 }
12521
12522
12523 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12524 PyObject *resultobj;
12525 wxImage *arg1 = (wxImage *) 0 ;
12526 SwigValueWrapper<wxImage > result;
12527 PyObject * obj0 = 0 ;
12528 char *kwnames[] = {
12529 (char *) "self", NULL
12530 };
12531
12532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12534 if (SWIG_arg_fail(1)) SWIG_fail;
12535 {
12536 PyThreadState* __tstate = wxPyBeginAllowThreads();
12537 result = (arg1)->Copy();
12538
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 {
12543 wxImage * resultptr;
12544 resultptr = new wxImage((wxImage &)(result));
12545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxImage *arg1 = (wxImage *) 0 ;
12556 wxImage *arg2 = 0 ;
12557 int arg3 ;
12558 int arg4 ;
12559 PyObject * obj0 = 0 ;
12560 PyObject * obj1 = 0 ;
12561 PyObject * obj2 = 0 ;
12562 PyObject * obj3 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 {
12571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12572 if (SWIG_arg_fail(2)) SWIG_fail;
12573 if (arg2 == NULL) {
12574 SWIG_null_ref("wxImage");
12575 }
12576 if (SWIG_arg_fail(2)) SWIG_fail;
12577 }
12578 {
12579 arg3 = (int)(SWIG_As_int(obj2));
12580 if (SWIG_arg_fail(3)) SWIG_fail;
12581 }
12582 {
12583 arg4 = (int)(SWIG_As_int(obj3));
12584 if (SWIG_arg_fail(4)) SWIG_fail;
12585 }
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 Py_INCREF(Py_None); resultobj = Py_None;
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj;
12602 wxImage *arg1 = (wxImage *) 0 ;
12603 PyObject *result;
12604 PyObject * obj0 = 0 ;
12605 char *kwnames[] = {
12606 (char *) "self", NULL
12607 };
12608
12609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12611 if (SWIG_arg_fail(1)) SWIG_fail;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (PyObject *)wxImage_GetData(arg1);
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 resultobj = result;
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj;
12628 wxImage *arg1 = (wxImage *) 0 ;
12629 buffer arg2 ;
12630 int arg3 ;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self",(char *) "data", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 {
12641 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12642 }
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 wxImage_SetData(arg1,arg2,arg3);
12646
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 Py_INCREF(Py_None); resultobj = Py_None;
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12658 PyObject *resultobj;
12659 wxImage *arg1 = (wxImage *) 0 ;
12660 PyObject *result;
12661 PyObject * obj0 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12672
12673 wxPyEndAllowThreads(__tstate);
12674 if (PyErr_Occurred()) SWIG_fail;
12675 }
12676 resultobj = result;
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12684 PyObject *resultobj;
12685 wxImage *arg1 = (wxImage *) 0 ;
12686 buffer arg2 ;
12687 int arg3 ;
12688 PyObject * obj0 = 0 ;
12689 PyObject * obj1 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self",(char *) "data", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12699 }
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 wxImage_SetDataBuffer(arg1,arg2,arg3);
12703
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 Py_INCREF(Py_None); resultobj = Py_None;
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj;
12716 wxImage *arg1 = (wxImage *) 0 ;
12717 PyObject *result;
12718 PyObject * obj0 = 0 ;
12719 char *kwnames[] = {
12720 (char *) "self", NULL
12721 };
12722
12723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12725 if (SWIG_arg_fail(1)) SWIG_fail;
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 result = (PyObject *)wxImage_GetAlphaData(arg1);
12729
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 resultobj = result;
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj;
12742 wxImage *arg1 = (wxImage *) 0 ;
12743 buffer arg2 ;
12744 int arg3 ;
12745 PyObject * obj0 = 0 ;
12746 PyObject * obj1 = 0 ;
12747 char *kwnames[] = {
12748 (char *) "self",(char *) "alpha", NULL
12749 };
12750
12751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12753 if (SWIG_arg_fail(1)) SWIG_fail;
12754 {
12755 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12756 }
12757 {
12758 PyThreadState* __tstate = wxPyBeginAllowThreads();
12759 wxImage_SetAlphaData(arg1,arg2,arg3);
12760
12761 wxPyEndAllowThreads(__tstate);
12762 if (PyErr_Occurred()) SWIG_fail;
12763 }
12764 Py_INCREF(Py_None); resultobj = Py_None;
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj;
12773 wxImage *arg1 = (wxImage *) 0 ;
12774 PyObject *result;
12775 PyObject * obj0 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12786
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 resultobj = result;
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12798 PyObject *resultobj;
12799 wxImage *arg1 = (wxImage *) 0 ;
12800 buffer arg2 ;
12801 int arg3 ;
12802 PyObject * obj0 = 0 ;
12803 PyObject * obj1 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "self",(char *) "alpha", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12810 if (SWIG_arg_fail(1)) SWIG_fail;
12811 {
12812 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12813 }
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 Py_INCREF(Py_None); resultobj = Py_None;
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12829 PyObject *resultobj;
12830 wxImage *arg1 = (wxImage *) 0 ;
12831 unsigned char arg2 ;
12832 unsigned char arg3 ;
12833 unsigned char arg4 ;
12834 PyObject * obj0 = 0 ;
12835 PyObject * obj1 = 0 ;
12836 PyObject * obj2 = 0 ;
12837 PyObject * obj3 = 0 ;
12838 char *kwnames[] = {
12839 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12840 };
12841
12842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 {
12846 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12847 if (SWIG_arg_fail(2)) SWIG_fail;
12848 }
12849 {
12850 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12851 if (SWIG_arg_fail(3)) SWIG_fail;
12852 }
12853 {
12854 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12855 if (SWIG_arg_fail(4)) SWIG_fail;
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->SetMaskColour(arg2,arg3,arg4);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxImage *arg1 = (wxImage *) 0 ;
12874 unsigned char *arg2 = (unsigned char *) 0 ;
12875 unsigned char *arg3 = (unsigned char *) 0 ;
12876 unsigned char *arg4 = (unsigned char *) 0 ;
12877 unsigned char temp2 ;
12878 int res2 = 0 ;
12879 unsigned char temp3 ;
12880 int res3 = 0 ;
12881 unsigned char temp4 ;
12882 int res4 = 0 ;
12883 PyObject * obj0 = 0 ;
12884 char *kwnames[] = {
12885 (char *) "self", NULL
12886 };
12887
12888 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12889 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12890 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12897
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 Py_INCREF(Py_None); resultobj = Py_None;
12902 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12903 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12904 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12905 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12906 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12907 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12908 return resultobj;
12909 fail:
12910 return NULL;
12911 }
12912
12913
12914 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12915 PyObject *resultobj;
12916 wxImage *arg1 = (wxImage *) 0 ;
12917 unsigned char result;
12918 PyObject * obj0 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 result = (unsigned char)(arg1)->GetMaskRed();
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 {
12934 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12935 }
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12943 PyObject *resultobj;
12944 wxImage *arg1 = (wxImage *) 0 ;
12945 unsigned char result;
12946 PyObject * obj0 = 0 ;
12947 char *kwnames[] = {
12948 (char *) "self", NULL
12949 };
12950
12951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12953 if (SWIG_arg_fail(1)) SWIG_fail;
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 result = (unsigned char)(arg1)->GetMaskGreen();
12957
12958 wxPyEndAllowThreads(__tstate);
12959 if (PyErr_Occurred()) SWIG_fail;
12960 }
12961 {
12962 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12963 }
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12971 PyObject *resultobj;
12972 wxImage *arg1 = (wxImage *) 0 ;
12973 unsigned char result;
12974 PyObject * obj0 = 0 ;
12975 char *kwnames[] = {
12976 (char *) "self", NULL
12977 };
12978
12979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12981 if (SWIG_arg_fail(1)) SWIG_fail;
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (unsigned char)(arg1)->GetMaskBlue();
12985
12986 wxPyEndAllowThreads(__tstate);
12987 if (PyErr_Occurred()) SWIG_fail;
12988 }
12989 {
12990 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12991 }
12992 return resultobj;
12993 fail:
12994 return NULL;
12995 }
12996
12997
12998 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12999 PyObject *resultobj;
13000 wxImage *arg1 = (wxImage *) 0 ;
13001 bool arg2 = (bool) true ;
13002 PyObject * obj0 = 0 ;
13003 PyObject * obj1 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self",(char *) "mask", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 if (obj1) {
13012 {
13013 arg2 = (bool)(SWIG_As_bool(obj1));
13014 if (SWIG_arg_fail(2)) SWIG_fail;
13015 }
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 (arg1)->SetMask(arg2);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 Py_INCREF(Py_None); resultobj = Py_None;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxImage *arg1 = (wxImage *) 0 ;
13034 bool result;
13035 PyObject * obj0 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (bool)(arg1)->HasMask();
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13052 }
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxImage *arg1 = (wxImage *) 0 ;
13062 double arg2 ;
13063 wxPoint *arg3 = 0 ;
13064 bool arg4 = (bool) true ;
13065 wxPoint *arg5 = (wxPoint *) NULL ;
13066 SwigValueWrapper<wxImage > result;
13067 wxPoint temp3 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 PyObject * obj3 = 0 ;
13072 PyObject * obj4 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13079 if (SWIG_arg_fail(1)) SWIG_fail;
13080 {
13081 arg2 = (double)(SWIG_As_double(obj1));
13082 if (SWIG_arg_fail(2)) SWIG_fail;
13083 }
13084 {
13085 arg3 = &temp3;
13086 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13087 }
13088 if (obj3) {
13089 {
13090 arg4 = (bool)(SWIG_As_bool(obj3));
13091 if (SWIG_arg_fail(4)) SWIG_fail;
13092 }
13093 }
13094 if (obj4) {
13095 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13096 if (SWIG_arg_fail(5)) SWIG_fail;
13097 }
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 {
13106 wxImage * resultptr;
13107 resultptr = new wxImage((wxImage &)(result));
13108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13109 }
13110 return resultobj;
13111 fail:
13112 return NULL;
13113 }
13114
13115
13116 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13117 PyObject *resultobj;
13118 wxImage *arg1 = (wxImage *) 0 ;
13119 bool arg2 = (bool) true ;
13120 SwigValueWrapper<wxImage > result;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 char *kwnames[] = {
13124 (char *) "self",(char *) "clockwise", NULL
13125 };
13126
13127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13129 if (SWIG_arg_fail(1)) SWIG_fail;
13130 if (obj1) {
13131 {
13132 arg2 = (bool)(SWIG_As_bool(obj1));
13133 if (SWIG_arg_fail(2)) SWIG_fail;
13134 }
13135 }
13136 {
13137 PyThreadState* __tstate = wxPyBeginAllowThreads();
13138 result = (arg1)->Rotate90(arg2);
13139
13140 wxPyEndAllowThreads(__tstate);
13141 if (PyErr_Occurred()) SWIG_fail;
13142 }
13143 {
13144 wxImage * resultptr;
13145 resultptr = new wxImage((wxImage &)(result));
13146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13147 }
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj;
13156 wxImage *arg1 = (wxImage *) 0 ;
13157 bool arg2 = (bool) true ;
13158 SwigValueWrapper<wxImage > result;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "self",(char *) "horizontally", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 if (obj1) {
13169 {
13170 arg2 = (bool)(SWIG_As_bool(obj1));
13171 if (SWIG_arg_fail(2)) SWIG_fail;
13172 }
13173 }
13174 {
13175 PyThreadState* __tstate = wxPyBeginAllowThreads();
13176 result = (arg1)->Mirror(arg2);
13177
13178 wxPyEndAllowThreads(__tstate);
13179 if (PyErr_Occurred()) SWIG_fail;
13180 }
13181 {
13182 wxImage * resultptr;
13183 resultptr = new wxImage((wxImage &)(result));
13184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13185 }
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj;
13194 wxImage *arg1 = (wxImage *) 0 ;
13195 unsigned char arg2 ;
13196 unsigned char arg3 ;
13197 unsigned char arg4 ;
13198 unsigned char arg5 ;
13199 unsigned char arg6 ;
13200 unsigned char arg7 ;
13201 PyObject * obj0 = 0 ;
13202 PyObject * obj1 = 0 ;
13203 PyObject * obj2 = 0 ;
13204 PyObject * obj3 = 0 ;
13205 PyObject * obj4 = 0 ;
13206 PyObject * obj5 = 0 ;
13207 PyObject * obj6 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13217 if (SWIG_arg_fail(2)) SWIG_fail;
13218 }
13219 {
13220 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13221 if (SWIG_arg_fail(3)) SWIG_fail;
13222 }
13223 {
13224 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13225 if (SWIG_arg_fail(4)) SWIG_fail;
13226 }
13227 {
13228 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13229 if (SWIG_arg_fail(5)) SWIG_fail;
13230 }
13231 {
13232 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13233 if (SWIG_arg_fail(6)) SWIG_fail;
13234 }
13235 {
13236 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13237 if (SWIG_arg_fail(7)) SWIG_fail;
13238 }
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13242
13243 wxPyEndAllowThreads(__tstate);
13244 if (PyErr_Occurred()) SWIG_fail;
13245 }
13246 Py_INCREF(Py_None); resultobj = Py_None;
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13254 PyObject *resultobj;
13255 wxImage *arg1 = (wxImage *) 0 ;
13256 unsigned char arg2 ;
13257 unsigned char arg3 ;
13258 unsigned char arg4 ;
13259 SwigValueWrapper<wxImage > result;
13260 PyObject * obj0 = 0 ;
13261 PyObject * obj1 = 0 ;
13262 PyObject * obj2 = 0 ;
13263 PyObject * obj3 = 0 ;
13264 char *kwnames[] = {
13265 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13266 };
13267
13268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13270 if (SWIG_arg_fail(1)) SWIG_fail;
13271 {
13272 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13273 if (SWIG_arg_fail(2)) SWIG_fail;
13274 }
13275 {
13276 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13277 if (SWIG_arg_fail(3)) SWIG_fail;
13278 }
13279 {
13280 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13281 if (SWIG_arg_fail(4)) SWIG_fail;
13282 }
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 {
13291 wxImage * resultptr;
13292 resultptr = new wxImage((wxImage &)(result));
13293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13294 }
13295 return resultobj;
13296 fail:
13297 return NULL;
13298 }
13299
13300
13301 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj;
13303 wxImage *arg1 = (wxImage *) 0 ;
13304 wxString *arg2 = 0 ;
13305 wxString *arg3 = 0 ;
13306 bool temp2 = false ;
13307 bool temp3 = false ;
13308 PyObject * obj0 = 0 ;
13309 PyObject * obj1 = 0 ;
13310 PyObject * obj2 = 0 ;
13311 char *kwnames[] = {
13312 (char *) "self",(char *) "name",(char *) "value", NULL
13313 };
13314
13315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13317 if (SWIG_arg_fail(1)) SWIG_fail;
13318 {
13319 arg2 = wxString_in_helper(obj1);
13320 if (arg2 == NULL) SWIG_fail;
13321 temp2 = true;
13322 }
13323 {
13324 arg3 = wxString_in_helper(obj2);
13325 if (arg3 == NULL) SWIG_fail;
13326 temp3 = true;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13331
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 Py_INCREF(Py_None); resultobj = Py_None;
13336 {
13337 if (temp2)
13338 delete arg2;
13339 }
13340 {
13341 if (temp3)
13342 delete arg3;
13343 }
13344 return resultobj;
13345 fail:
13346 {
13347 if (temp2)
13348 delete arg2;
13349 }
13350 {
13351 if (temp3)
13352 delete arg3;
13353 }
13354 return NULL;
13355 }
13356
13357
13358 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13359 PyObject *resultobj;
13360 wxImage *arg1 = (wxImage *) 0 ;
13361 wxString *arg2 = 0 ;
13362 int arg3 ;
13363 bool temp2 = false ;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 PyObject * obj2 = 0 ;
13367 char *kwnames[] = {
13368 (char *) "self",(char *) "name",(char *) "value", NULL
13369 };
13370
13371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13373 if (SWIG_arg_fail(1)) SWIG_fail;
13374 {
13375 arg2 = wxString_in_helper(obj1);
13376 if (arg2 == NULL) SWIG_fail;
13377 temp2 = true;
13378 }
13379 {
13380 arg3 = (int)(SWIG_As_int(obj2));
13381 if (SWIG_arg_fail(3)) SWIG_fail;
13382 }
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 (arg1)->SetOption((wxString const &)*arg2,arg3);
13386
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 Py_INCREF(Py_None); resultobj = Py_None;
13391 {
13392 if (temp2)
13393 delete arg2;
13394 }
13395 return resultobj;
13396 fail:
13397 {
13398 if (temp2)
13399 delete arg2;
13400 }
13401 return NULL;
13402 }
13403
13404
13405 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj;
13407 wxImage *arg1 = (wxImage *) 0 ;
13408 wxString *arg2 = 0 ;
13409 wxString result;
13410 bool temp2 = false ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 char *kwnames[] = {
13414 (char *) "self",(char *) "name", NULL
13415 };
13416
13417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13419 if (SWIG_arg_fail(1)) SWIG_fail;
13420 {
13421 arg2 = wxString_in_helper(obj1);
13422 if (arg2 == NULL) SWIG_fail;
13423 temp2 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13428
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp2)
13441 delete arg2;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp2)
13447 delete arg2;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxImage *arg1 = (wxImage *) 0 ;
13456 wxString *arg2 = 0 ;
13457 int result;
13458 bool temp2 = false ;
13459 PyObject * obj0 = 0 ;
13460 PyObject * obj1 = 0 ;
13461 char *kwnames[] = {
13462 (char *) "self",(char *) "name", NULL
13463 };
13464
13465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13467 if (SWIG_arg_fail(1)) SWIG_fail;
13468 {
13469 arg2 = wxString_in_helper(obj1);
13470 if (arg2 == NULL) SWIG_fail;
13471 temp2 = true;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 {
13481 resultobj = SWIG_From_int((int)(result));
13482 }
13483 {
13484 if (temp2)
13485 delete arg2;
13486 }
13487 return resultobj;
13488 fail:
13489 {
13490 if (temp2)
13491 delete arg2;
13492 }
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxImage *arg1 = (wxImage *) 0 ;
13500 wxString *arg2 = 0 ;
13501 bool result;
13502 bool temp2 = false ;
13503 PyObject * obj0 = 0 ;
13504 PyObject * obj1 = 0 ;
13505 char *kwnames[] = {
13506 (char *) "self",(char *) "name", NULL
13507 };
13508
13509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13511 if (SWIG_arg_fail(1)) SWIG_fail;
13512 {
13513 arg2 = wxString_in_helper(obj1);
13514 if (arg2 == NULL) SWIG_fail;
13515 temp2 = true;
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13520
13521 wxPyEndAllowThreads(__tstate);
13522 if (PyErr_Occurred()) SWIG_fail;
13523 }
13524 {
13525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13526 }
13527 {
13528 if (temp2)
13529 delete arg2;
13530 }
13531 return resultobj;
13532 fail:
13533 {
13534 if (temp2)
13535 delete arg2;
13536 }
13537 return NULL;
13538 }
13539
13540
13541 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxImage *arg1 = (wxImage *) 0 ;
13544 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13545 unsigned long result;
13546 PyObject * obj0 = 0 ;
13547 PyObject * obj1 = 0 ;
13548 char *kwnames[] = {
13549 (char *) "self",(char *) "stopafter", NULL
13550 };
13551
13552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13554 if (SWIG_arg_fail(1)) SWIG_fail;
13555 if (obj1) {
13556 {
13557 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13558 if (SWIG_arg_fail(2)) SWIG_fail;
13559 }
13560 }
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (unsigned long)(arg1)->CountColours(arg2);
13564
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13570 }
13571 return resultobj;
13572 fail:
13573 return NULL;
13574 }
13575
13576
13577 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj;
13579 wxImage *arg1 = (wxImage *) 0 ;
13580 wxImageHistogram *arg2 = 0 ;
13581 unsigned long result;
13582 PyObject * obj0 = 0 ;
13583 PyObject * obj1 = 0 ;
13584 char *kwnames[] = {
13585 (char *) "self",(char *) "h", NULL
13586 };
13587
13588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13590 if (SWIG_arg_fail(1)) SWIG_fail;
13591 {
13592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13593 if (SWIG_arg_fail(2)) SWIG_fail;
13594 if (arg2 == NULL) {
13595 SWIG_null_ref("wxImageHistogram");
13596 }
13597 if (SWIG_arg_fail(2)) SWIG_fail;
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13602
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 {
13607 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13608 }
13609 return resultobj;
13610 fail:
13611 return NULL;
13612 }
13613
13614
13615 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13616 PyObject *resultobj;
13617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13618 PyObject * obj0 = 0 ;
13619 char *kwnames[] = {
13620 (char *) "handler", NULL
13621 };
13622
13623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13625 if (SWIG_arg_fail(1)) SWIG_fail;
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 wxImage::AddHandler(arg1);
13629
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 Py_INCREF(Py_None); resultobj = Py_None;
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj;
13642 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13643 PyObject * obj0 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "handler", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 {
13652 PyThreadState* __tstate = wxPyBeginAllowThreads();
13653 wxImage::InsertHandler(arg1);
13654
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 Py_INCREF(Py_None); resultobj = Py_None;
13659 return resultobj;
13660 fail:
13661 return NULL;
13662 }
13663
13664
13665 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13666 PyObject *resultobj;
13667 wxString *arg1 = 0 ;
13668 bool result;
13669 bool temp1 = false ;
13670 PyObject * obj0 = 0 ;
13671 char *kwnames[] = {
13672 (char *) "name", NULL
13673 };
13674
13675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13676 {
13677 arg1 = wxString_in_helper(obj0);
13678 if (arg1 == NULL) SWIG_fail;
13679 temp1 = true;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13684
13685 wxPyEndAllowThreads(__tstate);
13686 if (PyErr_Occurred()) SWIG_fail;
13687 }
13688 {
13689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13690 }
13691 {
13692 if (temp1)
13693 delete arg1;
13694 }
13695 return resultobj;
13696 fail:
13697 {
13698 if (temp1)
13699 delete arg1;
13700 }
13701 return NULL;
13702 }
13703
13704
13705 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj;
13707 wxString result;
13708 char *kwnames[] = {
13709 NULL
13710 };
13711
13712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13713 {
13714 PyThreadState* __tstate = wxPyBeginAllowThreads();
13715 result = wxImage::GetImageExtWildcard();
13716
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 #if wxUSE_UNICODE
13722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13723 #else
13724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13725 #endif
13726 }
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxImage *arg1 = (wxImage *) 0 ;
13736 int arg2 = (int) -1 ;
13737 wxBitmap result;
13738 PyObject * obj0 = 0 ;
13739 PyObject * obj1 = 0 ;
13740 char *kwnames[] = {
13741 (char *) "self",(char *) "depth", NULL
13742 };
13743
13744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13746 if (SWIG_arg_fail(1)) SWIG_fail;
13747 if (obj1) {
13748 {
13749 arg2 = (int)(SWIG_As_int(obj1));
13750 if (SWIG_arg_fail(2)) SWIG_fail;
13751 }
13752 }
13753 {
13754 if (!wxPyCheckForApp()) SWIG_fail;
13755 PyThreadState* __tstate = wxPyBeginAllowThreads();
13756 result = wxImage_ConvertToBitmap(arg1,arg2);
13757
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 {
13762 wxBitmap * resultptr;
13763 resultptr = new wxBitmap((wxBitmap &)(result));
13764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13765 }
13766 return resultobj;
13767 fail:
13768 return NULL;
13769 }
13770
13771
13772 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj;
13774 wxImage *arg1 = (wxImage *) 0 ;
13775 unsigned char arg2 ;
13776 unsigned char arg3 ;
13777 unsigned char arg4 ;
13778 wxBitmap result;
13779 PyObject * obj0 = 0 ;
13780 PyObject * obj1 = 0 ;
13781 PyObject * obj2 = 0 ;
13782 PyObject * obj3 = 0 ;
13783 char *kwnames[] = {
13784 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13785 };
13786
13787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 {
13791 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13792 if (SWIG_arg_fail(2)) SWIG_fail;
13793 }
13794 {
13795 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13796 if (SWIG_arg_fail(3)) SWIG_fail;
13797 }
13798 {
13799 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13800 if (SWIG_arg_fail(4)) SWIG_fail;
13801 }
13802 {
13803 if (!wxPyCheckForApp()) SWIG_fail;
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13806
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 {
13811 wxBitmap * resultptr;
13812 resultptr = new wxBitmap((wxBitmap &)(result));
13813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13814 }
13815 return resultobj;
13816 fail:
13817 return NULL;
13818 }
13819
13820
13821 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13822 PyObject *obj;
13823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13824 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13825 Py_INCREF(obj);
13826 return Py_BuildValue((char *)"");
13827 }
13828 static int _wrap_NullImage_set(PyObject *) {
13829 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13830 return 1;
13831 }
13832
13833
13834 static PyObject *_wrap_NullImage_get(void) {
13835 PyObject *pyobj;
13836
13837 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13838 return pyobj;
13839 }
13840
13841
13842 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13843 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13844 return 1;
13845 }
13846
13847
13848 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13849 PyObject *pyobj;
13850
13851 {
13852 #if wxUSE_UNICODE
13853 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13854 #else
13855 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13856 #endif
13857 }
13858 return pyobj;
13859 }
13860
13861
13862 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13863 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13864 return 1;
13865 }
13866
13867
13868 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13869 PyObject *pyobj;
13870
13871 {
13872 #if wxUSE_UNICODE
13873 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13874 #else
13875 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13876 #endif
13877 }
13878 return pyobj;
13879 }
13880
13881
13882 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13883 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13884 return 1;
13885 }
13886
13887
13888 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13889 PyObject *pyobj;
13890
13891 {
13892 #if wxUSE_UNICODE
13893 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13894 #else
13895 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13896 #endif
13897 }
13898 return pyobj;
13899 }
13900
13901
13902 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13903 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13904 return 1;
13905 }
13906
13907
13908 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13909 PyObject *pyobj;
13910
13911 {
13912 #if wxUSE_UNICODE
13913 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13914 #else
13915 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13916 #endif
13917 }
13918 return pyobj;
13919 }
13920
13921
13922 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13923 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13924 return 1;
13925 }
13926
13927
13928 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13929 PyObject *pyobj;
13930
13931 {
13932 #if wxUSE_UNICODE
13933 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13934 #else
13935 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13936 #endif
13937 }
13938 return pyobj;
13939 }
13940
13941
13942 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13943 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13944 return 1;
13945 }
13946
13947
13948 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13949 PyObject *pyobj;
13950
13951 {
13952 #if wxUSE_UNICODE
13953 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13954 #else
13955 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13956 #endif
13957 }
13958 return pyobj;
13959 }
13960
13961
13962 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13963 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13964 return 1;
13965 }
13966
13967
13968 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13969 PyObject *pyobj;
13970
13971 {
13972 #if wxUSE_UNICODE
13973 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13974 #else
13975 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13976 #endif
13977 }
13978 return pyobj;
13979 }
13980
13981
13982 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13983 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13984 return 1;
13985 }
13986
13987
13988 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13989 PyObject *pyobj;
13990
13991 {
13992 #if wxUSE_UNICODE
13993 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13994 #else
13995 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13996 #endif
13997 }
13998 return pyobj;
13999 }
14000
14001
14002 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14003 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14004 return 1;
14005 }
14006
14007
14008 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14009 PyObject *pyobj;
14010
14011 {
14012 #if wxUSE_UNICODE
14013 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14014 #else
14015 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14016 #endif
14017 }
14018 return pyobj;
14019 }
14020
14021
14022 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14023 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14024 return 1;
14025 }
14026
14027
14028 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14029 PyObject *pyobj;
14030
14031 {
14032 #if wxUSE_UNICODE
14033 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14034 #else
14035 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14036 #endif
14037 }
14038 return pyobj;
14039 }
14040
14041
14042 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14043 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14044 return 1;
14045 }
14046
14047
14048 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14049 PyObject *pyobj;
14050
14051 {
14052 #if wxUSE_UNICODE
14053 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14054 #else
14055 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14056 #endif
14057 }
14058 return pyobj;
14059 }
14060
14061
14062 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14063 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14064 return 1;
14065 }
14066
14067
14068 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14069 PyObject *pyobj;
14070
14071 {
14072 #if wxUSE_UNICODE
14073 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14074 #else
14075 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14076 #endif
14077 }
14078 return pyobj;
14079 }
14080
14081
14082 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14083 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14084 return 1;
14085 }
14086
14087
14088 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14089 PyObject *pyobj;
14090
14091 {
14092 #if wxUSE_UNICODE
14093 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14094 #else
14095 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14096 #endif
14097 }
14098 return pyobj;
14099 }
14100
14101
14102 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14103 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14104 return 1;
14105 }
14106
14107
14108 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14109 PyObject *pyobj;
14110
14111 {
14112 #if wxUSE_UNICODE
14113 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14114 #else
14115 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14116 #endif
14117 }
14118 return pyobj;
14119 }
14120
14121
14122 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14123 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14124 return 1;
14125 }
14126
14127
14128 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14129 PyObject *pyobj;
14130
14131 {
14132 #if wxUSE_UNICODE
14133 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14134 #else
14135 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14136 #endif
14137 }
14138 return pyobj;
14139 }
14140
14141
14142 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxBMPHandler *result;
14145 char *kwnames[] = {
14146 NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (wxBMPHandler *)new wxBMPHandler();
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14165 PyObject *obj;
14166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14167 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14168 Py_INCREF(obj);
14169 return Py_BuildValue((char *)"");
14170 }
14171 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj;
14173 wxICOHandler *result;
14174 char *kwnames[] = {
14175 NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14179 {
14180 PyThreadState* __tstate = wxPyBeginAllowThreads();
14181 result = (wxICOHandler *)new wxICOHandler();
14182
14183 wxPyEndAllowThreads(__tstate);
14184 if (PyErr_Occurred()) SWIG_fail;
14185 }
14186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14187 return resultobj;
14188 fail:
14189 return NULL;
14190 }
14191
14192
14193 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14194 PyObject *obj;
14195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14196 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14197 Py_INCREF(obj);
14198 return Py_BuildValue((char *)"");
14199 }
14200 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14201 PyObject *resultobj;
14202 wxCURHandler *result;
14203 char *kwnames[] = {
14204 NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (wxCURHandler *)new wxCURHandler();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14216 return resultobj;
14217 fail:
14218 return NULL;
14219 }
14220
14221
14222 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14223 PyObject *obj;
14224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14225 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14226 Py_INCREF(obj);
14227 return Py_BuildValue((char *)"");
14228 }
14229 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxANIHandler *result;
14232 char *kwnames[] = {
14233 NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 result = (wxANIHandler *)new wxANIHandler();
14240
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14252 PyObject *obj;
14253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14254 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14255 Py_INCREF(obj);
14256 return Py_BuildValue((char *)"");
14257 }
14258 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj;
14260 wxPNGHandler *result;
14261 char *kwnames[] = {
14262 NULL
14263 };
14264
14265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (wxPNGHandler *)new wxPNGHandler();
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14281 PyObject *obj;
14282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14283 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14284 Py_INCREF(obj);
14285 return Py_BuildValue((char *)"");
14286 }
14287 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14288 PyObject *resultobj;
14289 wxGIFHandler *result;
14290 char *kwnames[] = {
14291 NULL
14292 };
14293
14294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14295 {
14296 PyThreadState* __tstate = wxPyBeginAllowThreads();
14297 result = (wxGIFHandler *)new wxGIFHandler();
14298
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14303 return resultobj;
14304 fail:
14305 return NULL;
14306 }
14307
14308
14309 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14310 PyObject *obj;
14311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14312 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14313 Py_INCREF(obj);
14314 return Py_BuildValue((char *)"");
14315 }
14316 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj;
14318 wxPCXHandler *result;
14319 char *kwnames[] = {
14320 NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14324 {
14325 PyThreadState* __tstate = wxPyBeginAllowThreads();
14326 result = (wxPCXHandler *)new wxPCXHandler();
14327
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14339 PyObject *obj;
14340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14341 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14342 Py_INCREF(obj);
14343 return Py_BuildValue((char *)"");
14344 }
14345 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj;
14347 wxJPEGHandler *result;
14348 char *kwnames[] = {
14349 NULL
14350 };
14351
14352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (wxJPEGHandler *)new wxJPEGHandler();
14356
14357 wxPyEndAllowThreads(__tstate);
14358 if (PyErr_Occurred()) SWIG_fail;
14359 }
14360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14361 return resultobj;
14362 fail:
14363 return NULL;
14364 }
14365
14366
14367 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14368 PyObject *obj;
14369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14370 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14371 Py_INCREF(obj);
14372 return Py_BuildValue((char *)"");
14373 }
14374 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14375 PyObject *resultobj;
14376 wxPNMHandler *result;
14377 char *kwnames[] = {
14378 NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (wxPNMHandler *)new wxPNMHandler();
14385
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14397 PyObject *obj;
14398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14399 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14400 Py_INCREF(obj);
14401 return Py_BuildValue((char *)"");
14402 }
14403 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj;
14405 wxXPMHandler *result;
14406 char *kwnames[] = {
14407 NULL
14408 };
14409
14410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (wxXPMHandler *)new wxXPMHandler();
14414
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14426 PyObject *obj;
14427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14428 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14429 Py_INCREF(obj);
14430 return Py_BuildValue((char *)"");
14431 }
14432 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14433 PyObject *resultobj;
14434 wxTIFFHandler *result;
14435 char *kwnames[] = {
14436 NULL
14437 };
14438
14439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (wxTIFFHandler *)new wxTIFFHandler();
14443
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14455 PyObject *obj;
14456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14457 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14458 Py_INCREF(obj);
14459 return Py_BuildValue((char *)"");
14460 }
14461 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14462 PyObject *resultobj;
14463 wxImage *arg1 = 0 ;
14464 wxImage *arg2 = 0 ;
14465 int arg3 = (int) 236 ;
14466 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14467 bool result;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 PyObject * obj3 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14477 {
14478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 if (arg1 == NULL) {
14481 SWIG_null_ref("wxImage");
14482 }
14483 if (SWIG_arg_fail(1)) SWIG_fail;
14484 }
14485 {
14486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14487 if (SWIG_arg_fail(2)) SWIG_fail;
14488 if (arg2 == NULL) {
14489 SWIG_null_ref("wxImage");
14490 }
14491 if (SWIG_arg_fail(2)) SWIG_fail;
14492 }
14493 if (obj2) {
14494 {
14495 arg3 = (int)(SWIG_As_int(obj2));
14496 if (SWIG_arg_fail(3)) SWIG_fail;
14497 }
14498 }
14499 if (obj3) {
14500 {
14501 arg4 = (int)(SWIG_As_int(obj3));
14502 if (SWIG_arg_fail(4)) SWIG_fail;
14503 }
14504 }
14505 {
14506 PyThreadState* __tstate = wxPyBeginAllowThreads();
14507 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14508
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 {
14513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14514 }
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14522 PyObject *obj;
14523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14524 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14525 Py_INCREF(obj);
14526 return Py_BuildValue((char *)"");
14527 }
14528 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxEvtHandler *result;
14531 char *kwnames[] = {
14532 NULL
14533 };
14534
14535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 result = (wxEvtHandler *)new wxEvtHandler();
14539
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj;
14552 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14553 wxEvtHandler *result;
14554 PyObject * obj0 = 0 ;
14555 char *kwnames[] = {
14556 (char *) "self", NULL
14557 };
14558
14559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14561 if (SWIG_arg_fail(1)) SWIG_fail;
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14565
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 {
14570 resultobj = wxPyMake_wxObject(result, 0);
14571 }
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14579 PyObject *resultobj;
14580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14581 wxEvtHandler *result;
14582 PyObject * obj0 = 0 ;
14583 char *kwnames[] = {
14584 (char *) "self", NULL
14585 };
14586
14587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14589 if (SWIG_arg_fail(1)) SWIG_fail;
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14593
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 {
14598 resultobj = wxPyMake_wxObject(result, 0);
14599 }
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14607 PyObject *resultobj;
14608 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14609 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 char *kwnames[] = {
14613 (char *) "self",(char *) "handler", NULL
14614 };
14615
14616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14618 if (SWIG_arg_fail(1)) SWIG_fail;
14619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14620 if (SWIG_arg_fail(2)) SWIG_fail;
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 (arg1)->SetNextHandler(arg2);
14624
14625 wxPyEndAllowThreads(__tstate);
14626 if (PyErr_Occurred()) SWIG_fail;
14627 }
14628 Py_INCREF(Py_None); resultobj = Py_None;
14629 return resultobj;
14630 fail:
14631 return NULL;
14632 }
14633
14634
14635 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14636 PyObject *resultobj;
14637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14638 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 char *kwnames[] = {
14642 (char *) "self",(char *) "handler", NULL
14643 };
14644
14645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14647 if (SWIG_arg_fail(1)) SWIG_fail;
14648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14649 if (SWIG_arg_fail(2)) SWIG_fail;
14650 {
14651 PyThreadState* __tstate = wxPyBeginAllowThreads();
14652 (arg1)->SetPreviousHandler(arg2);
14653
14654 wxPyEndAllowThreads(__tstate);
14655 if (PyErr_Occurred()) SWIG_fail;
14656 }
14657 Py_INCREF(Py_None); resultobj = Py_None;
14658 return resultobj;
14659 fail:
14660 return NULL;
14661 }
14662
14663
14664 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14665 PyObject *resultobj;
14666 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14667 bool result;
14668 PyObject * obj0 = 0 ;
14669 char *kwnames[] = {
14670 (char *) "self", NULL
14671 };
14672
14673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14675 if (SWIG_arg_fail(1)) SWIG_fail;
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->GetEvtHandlerEnabled();
14679
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 {
14684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14685 }
14686 return resultobj;
14687 fail:
14688 return NULL;
14689 }
14690
14691
14692 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14693 PyObject *resultobj;
14694 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14695 bool arg2 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 char *kwnames[] = {
14699 (char *) "self",(char *) "enabled", NULL
14700 };
14701
14702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14704 if (SWIG_arg_fail(1)) SWIG_fail;
14705 {
14706 arg2 = (bool)(SWIG_As_bool(obj1));
14707 if (SWIG_arg_fail(2)) SWIG_fail;
14708 }
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 (arg1)->SetEvtHandlerEnabled(arg2);
14712
14713 wxPyEndAllowThreads(__tstate);
14714 if (PyErr_Occurred()) SWIG_fail;
14715 }
14716 Py_INCREF(Py_None); resultobj = Py_None;
14717 return resultobj;
14718 fail:
14719 return NULL;
14720 }
14721
14722
14723 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14724 PyObject *resultobj;
14725 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14726 wxEvent *arg2 = 0 ;
14727 bool result;
14728 PyObject * obj0 = 0 ;
14729 PyObject * obj1 = 0 ;
14730 char *kwnames[] = {
14731 (char *) "self",(char *) "event", NULL
14732 };
14733
14734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14736 if (SWIG_arg_fail(1)) SWIG_fail;
14737 {
14738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14739 if (SWIG_arg_fail(2)) SWIG_fail;
14740 if (arg2 == NULL) {
14741 SWIG_null_ref("wxEvent");
14742 }
14743 if (SWIG_arg_fail(2)) SWIG_fail;
14744 }
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (bool)(arg1)->ProcessEvent(*arg2);
14748
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 {
14753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14754 }
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj;
14763 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14764 wxEvent *arg2 = 0 ;
14765 PyObject * obj0 = 0 ;
14766 PyObject * obj1 = 0 ;
14767 char *kwnames[] = {
14768 (char *) "self",(char *) "event", NULL
14769 };
14770
14771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14773 if (SWIG_arg_fail(1)) SWIG_fail;
14774 {
14775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 if (arg2 == NULL) {
14778 SWIG_null_ref("wxEvent");
14779 }
14780 if (SWIG_arg_fail(2)) SWIG_fail;
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 (arg1)->AddPendingEvent(*arg2);
14785
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 Py_INCREF(Py_None); resultobj = Py_None;
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj;
14798 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14799 PyObject * obj0 = 0 ;
14800 char *kwnames[] = {
14801 (char *) "self", NULL
14802 };
14803
14804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14806 if (SWIG_arg_fail(1)) SWIG_fail;
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 (arg1)->ProcessPendingEvents();
14810
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 Py_INCREF(Py_None); resultobj = Py_None;
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj;
14823 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14824 int arg2 ;
14825 int arg3 ;
14826 int arg4 ;
14827 PyObject *arg5 = (PyObject *) 0 ;
14828 PyObject * obj0 = 0 ;
14829 PyObject * obj1 = 0 ;
14830 PyObject * obj2 = 0 ;
14831 PyObject * obj3 = 0 ;
14832 PyObject * obj4 = 0 ;
14833 char *kwnames[] = {
14834 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14835 };
14836
14837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14839 if (SWIG_arg_fail(1)) SWIG_fail;
14840 {
14841 arg2 = (int)(SWIG_As_int(obj1));
14842 if (SWIG_arg_fail(2)) SWIG_fail;
14843 }
14844 {
14845 arg3 = (int)(SWIG_As_int(obj2));
14846 if (SWIG_arg_fail(3)) SWIG_fail;
14847 }
14848 {
14849 arg4 = (int)(SWIG_As_int(obj3));
14850 if (SWIG_arg_fail(4)) SWIG_fail;
14851 }
14852 arg5 = obj4;
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14856
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 Py_INCREF(Py_None); resultobj = Py_None;
14861 return resultobj;
14862 fail:
14863 return NULL;
14864 }
14865
14866
14867 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14868 PyObject *resultobj;
14869 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14870 int arg2 ;
14871 int arg3 = (int) -1 ;
14872 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14873 bool result;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 PyObject * obj3 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14884 if (SWIG_arg_fail(1)) SWIG_fail;
14885 {
14886 arg2 = (int)(SWIG_As_int(obj1));
14887 if (SWIG_arg_fail(2)) SWIG_fail;
14888 }
14889 if (obj2) {
14890 {
14891 arg3 = (int)(SWIG_As_int(obj2));
14892 if (SWIG_arg_fail(3)) SWIG_fail;
14893 }
14894 }
14895 if (obj3) {
14896 {
14897 arg4 = (wxEventType)(SWIG_As_int(obj3));
14898 if (SWIG_arg_fail(4)) SWIG_fail;
14899 }
14900 }
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14904
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 {
14909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14910 }
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj;
14919 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14920 PyObject *arg2 = (PyObject *) 0 ;
14921 bool arg3 = (bool) true ;
14922 PyObject * obj0 = 0 ;
14923 PyObject * obj1 = 0 ;
14924 PyObject * obj2 = 0 ;
14925 char *kwnames[] = {
14926 (char *) "self",(char *) "_self",(char *) "incref", NULL
14927 };
14928
14929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14931 if (SWIG_arg_fail(1)) SWIG_fail;
14932 arg2 = obj1;
14933 if (obj2) {
14934 {
14935 arg3 = (bool)(SWIG_As_bool(obj2));
14936 if (SWIG_arg_fail(3)) SWIG_fail;
14937 }
14938 }
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 Py_INCREF(Py_None); resultobj = Py_None;
14947 return resultobj;
14948 fail:
14949 return NULL;
14950 }
14951
14952
14953 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14954 PyObject *obj;
14955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14956 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14957 Py_INCREF(obj);
14958 return Py_BuildValue((char *)"");
14959 }
14960 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj;
14962 wxEventType result;
14963 char *kwnames[] = {
14964 NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 result = (wxEventType)wxNewEventType();
14971
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 {
14976 resultobj = SWIG_From_int((int)(result));
14977 }
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14985 PyObject *resultobj;
14986 wxEvent *arg1 = (wxEvent *) 0 ;
14987 PyObject * obj0 = 0 ;
14988 char *kwnames[] = {
14989 (char *) "self", NULL
14990 };
14991
14992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14994 if (SWIG_arg_fail(1)) SWIG_fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 delete arg1;
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 Py_INCREF(Py_None); resultobj = Py_None;
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj;
15011 wxEvent *arg1 = (wxEvent *) 0 ;
15012 wxEventType arg2 ;
15013 PyObject * obj0 = 0 ;
15014 PyObject * obj1 = 0 ;
15015 char *kwnames[] = {
15016 (char *) "self",(char *) "typ", NULL
15017 };
15018
15019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15021 if (SWIG_arg_fail(1)) SWIG_fail;
15022 {
15023 arg2 = (wxEventType)(SWIG_As_int(obj1));
15024 if (SWIG_arg_fail(2)) SWIG_fail;
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 (arg1)->SetEventType(arg2);
15029
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 Py_INCREF(Py_None); resultobj = Py_None;
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15041 PyObject *resultobj;
15042 wxEvent *arg1 = (wxEvent *) 0 ;
15043 wxEventType result;
15044 PyObject * obj0 = 0 ;
15045 char *kwnames[] = {
15046 (char *) "self", NULL
15047 };
15048
15049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15051 if (SWIG_arg_fail(1)) SWIG_fail;
15052 {
15053 PyThreadState* __tstate = wxPyBeginAllowThreads();
15054 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15055
15056 wxPyEndAllowThreads(__tstate);
15057 if (PyErr_Occurred()) SWIG_fail;
15058 }
15059 {
15060 resultobj = SWIG_From_int((int)(result));
15061 }
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15069 PyObject *resultobj;
15070 wxEvent *arg1 = (wxEvent *) 0 ;
15071 wxObject *result;
15072 PyObject * obj0 = 0 ;
15073 char *kwnames[] = {
15074 (char *) "self", NULL
15075 };
15076
15077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15079 if (SWIG_arg_fail(1)) SWIG_fail;
15080 {
15081 PyThreadState* __tstate = wxPyBeginAllowThreads();
15082 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15083
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 {
15088 resultobj = wxPyMake_wxObject(result, 0);
15089 }
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15097 PyObject *resultobj;
15098 wxEvent *arg1 = (wxEvent *) 0 ;
15099 wxObject *arg2 = (wxObject *) 0 ;
15100 PyObject * obj0 = 0 ;
15101 PyObject * obj1 = 0 ;
15102 char *kwnames[] = {
15103 (char *) "self",(char *) "obj", NULL
15104 };
15105
15106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15108 if (SWIG_arg_fail(1)) SWIG_fail;
15109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15110 if (SWIG_arg_fail(2)) SWIG_fail;
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 (arg1)->SetEventObject(arg2);
15114
15115 wxPyEndAllowThreads(__tstate);
15116 if (PyErr_Occurred()) SWIG_fail;
15117 }
15118 Py_INCREF(Py_None); resultobj = Py_None;
15119 return resultobj;
15120 fail:
15121 return NULL;
15122 }
15123
15124
15125 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15126 PyObject *resultobj;
15127 wxEvent *arg1 = (wxEvent *) 0 ;
15128 long result;
15129 PyObject * obj0 = 0 ;
15130 char *kwnames[] = {
15131 (char *) "self", NULL
15132 };
15133
15134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15136 if (SWIG_arg_fail(1)) SWIG_fail;
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 {
15145 resultobj = SWIG_From_long((long)(result));
15146 }
15147 return resultobj;
15148 fail:
15149 return NULL;
15150 }
15151
15152
15153 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15154 PyObject *resultobj;
15155 wxEvent *arg1 = (wxEvent *) 0 ;
15156 long arg2 = (long) 0 ;
15157 PyObject * obj0 = 0 ;
15158 PyObject * obj1 = 0 ;
15159 char *kwnames[] = {
15160 (char *) "self",(char *) "ts", NULL
15161 };
15162
15163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15165 if (SWIG_arg_fail(1)) SWIG_fail;
15166 if (obj1) {
15167 {
15168 arg2 = (long)(SWIG_As_long(obj1));
15169 if (SWIG_arg_fail(2)) SWIG_fail;
15170 }
15171 }
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 (arg1)->SetTimestamp(arg2);
15175
15176 wxPyEndAllowThreads(__tstate);
15177 if (PyErr_Occurred()) SWIG_fail;
15178 }
15179 Py_INCREF(Py_None); resultobj = Py_None;
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj;
15188 wxEvent *arg1 = (wxEvent *) 0 ;
15189 int result;
15190 PyObject * obj0 = 0 ;
15191 char *kwnames[] = {
15192 (char *) "self", NULL
15193 };
15194
15195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15197 if (SWIG_arg_fail(1)) SWIG_fail;
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (int)((wxEvent const *)arg1)->GetId();
15201
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 {
15206 resultobj = SWIG_From_int((int)(result));
15207 }
15208 return resultobj;
15209 fail:
15210 return NULL;
15211 }
15212
15213
15214 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15215 PyObject *resultobj;
15216 wxEvent *arg1 = (wxEvent *) 0 ;
15217 int arg2 ;
15218 PyObject * obj0 = 0 ;
15219 PyObject * obj1 = 0 ;
15220 char *kwnames[] = {
15221 (char *) "self",(char *) "Id", NULL
15222 };
15223
15224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 {
15228 arg2 = (int)(SWIG_As_int(obj1));
15229 if (SWIG_arg_fail(2)) SWIG_fail;
15230 }
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 (arg1)->SetId(arg2);
15234
15235 wxPyEndAllowThreads(__tstate);
15236 if (PyErr_Occurred()) SWIG_fail;
15237 }
15238 Py_INCREF(Py_None); resultobj = Py_None;
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15246 PyObject *resultobj;
15247 wxEvent *arg1 = (wxEvent *) 0 ;
15248 bool result;
15249 PyObject * obj0 = 0 ;
15250 char *kwnames[] = {
15251 (char *) "self", NULL
15252 };
15253
15254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(1)) SWIG_fail;
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15260
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 {
15265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15266 }
15267 return resultobj;
15268 fail:
15269 return NULL;
15270 }
15271
15272
15273 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15274 PyObject *resultobj;
15275 wxEvent *arg1 = (wxEvent *) 0 ;
15276 bool arg2 = (bool) true ;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self",(char *) "skip", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15285 if (SWIG_arg_fail(1)) SWIG_fail;
15286 if (obj1) {
15287 {
15288 arg2 = (bool)(SWIG_As_bool(obj1));
15289 if (SWIG_arg_fail(2)) SWIG_fail;
15290 }
15291 }
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 (arg1)->Skip(arg2);
15295
15296 wxPyEndAllowThreads(__tstate);
15297 if (PyErr_Occurred()) SWIG_fail;
15298 }
15299 Py_INCREF(Py_None); resultobj = Py_None;
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj;
15308 wxEvent *arg1 = (wxEvent *) 0 ;
15309 bool result;
15310 PyObject * obj0 = 0 ;
15311 char *kwnames[] = {
15312 (char *) "self", NULL
15313 };
15314
15315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15317 if (SWIG_arg_fail(1)) SWIG_fail;
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxEvent *arg1 = (wxEvent *) 0 ;
15337 bool result;
15338 PyObject * obj0 = 0 ;
15339 char *kwnames[] = {
15340 (char *) "self", NULL
15341 };
15342
15343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15345 if (SWIG_arg_fail(1)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15349
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 {
15354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15355 }
15356 return resultobj;
15357 fail:
15358 return NULL;
15359 }
15360
15361
15362 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15363 PyObject *resultobj;
15364 wxEvent *arg1 = (wxEvent *) 0 ;
15365 int result;
15366 PyObject * obj0 = 0 ;
15367 char *kwnames[] = {
15368 (char *) "self", NULL
15369 };
15370
15371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15373 if (SWIG_arg_fail(1)) SWIG_fail;
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (int)(arg1)->StopPropagation();
15377
15378 wxPyEndAllowThreads(__tstate);
15379 if (PyErr_Occurred()) SWIG_fail;
15380 }
15381 {
15382 resultobj = SWIG_From_int((int)(result));
15383 }
15384 return resultobj;
15385 fail:
15386 return NULL;
15387 }
15388
15389
15390 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15391 PyObject *resultobj;
15392 wxEvent *arg1 = (wxEvent *) 0 ;
15393 int arg2 ;
15394 PyObject * obj0 = 0 ;
15395 PyObject * obj1 = 0 ;
15396 char *kwnames[] = {
15397 (char *) "self",(char *) "propagationLevel", NULL
15398 };
15399
15400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15402 if (SWIG_arg_fail(1)) SWIG_fail;
15403 {
15404 arg2 = (int)(SWIG_As_int(obj1));
15405 if (SWIG_arg_fail(2)) SWIG_fail;
15406 }
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 (arg1)->ResumePropagation(arg2);
15410
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 Py_INCREF(Py_None); resultobj = Py_None;
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj;
15423 wxEvent *arg1 = (wxEvent *) 0 ;
15424 wxEvent *result;
15425 PyObject * obj0 = 0 ;
15426 char *kwnames[] = {
15427 (char *) "self", NULL
15428 };
15429
15430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15432 if (SWIG_arg_fail(1)) SWIG_fail;
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 result = (wxEvent *)(arg1)->Clone();
15436
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15448 PyObject *obj;
15449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15450 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15451 Py_INCREF(obj);
15452 return Py_BuildValue((char *)"");
15453 }
15454 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15455 PyObject *resultobj;
15456 wxEvent *arg1 = 0 ;
15457 wxPropagationDisabler *result;
15458 PyObject * obj0 = 0 ;
15459 char *kwnames[] = {
15460 (char *) "event", NULL
15461 };
15462
15463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15464 {
15465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15466 if (SWIG_arg_fail(1)) SWIG_fail;
15467 if (arg1 == NULL) {
15468 SWIG_null_ref("wxEvent");
15469 }
15470 if (SWIG_arg_fail(1)) SWIG_fail;
15471 }
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15475
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj;
15488 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15489 PyObject * obj0 = 0 ;
15490 char *kwnames[] = {
15491 (char *) "self", NULL
15492 };
15493
15494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15496 if (SWIG_arg_fail(1)) SWIG_fail;
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 delete arg1;
15500
15501 wxPyEndAllowThreads(__tstate);
15502 if (PyErr_Occurred()) SWIG_fail;
15503 }
15504 Py_INCREF(Py_None); resultobj = Py_None;
15505 return resultobj;
15506 fail:
15507 return NULL;
15508 }
15509
15510
15511 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15512 PyObject *obj;
15513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15514 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15515 Py_INCREF(obj);
15516 return Py_BuildValue((char *)"");
15517 }
15518 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj;
15520 wxEvent *arg1 = 0 ;
15521 wxPropagateOnce *result;
15522 PyObject * obj0 = 0 ;
15523 char *kwnames[] = {
15524 (char *) "event", NULL
15525 };
15526
15527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15528 {
15529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 if (arg1 == NULL) {
15532 SWIG_null_ref("wxEvent");
15533 }
15534 if (SWIG_arg_fail(1)) SWIG_fail;
15535 }
15536 {
15537 PyThreadState* __tstate = wxPyBeginAllowThreads();
15538 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15539
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj;
15552 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15553 PyObject * obj0 = 0 ;
15554 char *kwnames[] = {
15555 (char *) "self", NULL
15556 };
15557
15558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15560 if (SWIG_arg_fail(1)) SWIG_fail;
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 delete arg1;
15564
15565 wxPyEndAllowThreads(__tstate);
15566 if (PyErr_Occurred()) SWIG_fail;
15567 }
15568 Py_INCREF(Py_None); resultobj = Py_None;
15569 return resultobj;
15570 fail:
15571 return NULL;
15572 }
15573
15574
15575 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15576 PyObject *obj;
15577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15578 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15579 Py_INCREF(obj);
15580 return Py_BuildValue((char *)"");
15581 }
15582 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj;
15584 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15585 int arg2 = (int) 0 ;
15586 wxCommandEvent *result;
15587 PyObject * obj0 = 0 ;
15588 PyObject * obj1 = 0 ;
15589 char *kwnames[] = {
15590 (char *) "commandType",(char *) "winid", NULL
15591 };
15592
15593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15594 if (obj0) {
15595 {
15596 arg1 = (wxEventType)(SWIG_As_int(obj0));
15597 if (SWIG_arg_fail(1)) SWIG_fail;
15598 }
15599 }
15600 if (obj1) {
15601 {
15602 arg2 = (int)(SWIG_As_int(obj1));
15603 if (SWIG_arg_fail(2)) SWIG_fail;
15604 }
15605 }
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15609
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15614 return resultobj;
15615 fail:
15616 return NULL;
15617 }
15618
15619
15620 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15621 PyObject *resultobj;
15622 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15623 int result;
15624 PyObject * obj0 = 0 ;
15625 char *kwnames[] = {
15626 (char *) "self", NULL
15627 };
15628
15629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15631 if (SWIG_arg_fail(1)) SWIG_fail;
15632 {
15633 PyThreadState* __tstate = wxPyBeginAllowThreads();
15634 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15635
15636 wxPyEndAllowThreads(__tstate);
15637 if (PyErr_Occurred()) SWIG_fail;
15638 }
15639 {
15640 resultobj = SWIG_From_int((int)(result));
15641 }
15642 return resultobj;
15643 fail:
15644 return NULL;
15645 }
15646
15647
15648 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15649 PyObject *resultobj;
15650 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15651 wxString *arg2 = 0 ;
15652 bool temp2 = false ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self",(char *) "s", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 arg2 = wxString_in_helper(obj1);
15664 if (arg2 == NULL) SWIG_fail;
15665 temp2 = true;
15666 }
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 (arg1)->SetString((wxString const &)*arg2);
15670
15671 wxPyEndAllowThreads(__tstate);
15672 if (PyErr_Occurred()) SWIG_fail;
15673 }
15674 Py_INCREF(Py_None); resultobj = Py_None;
15675 {
15676 if (temp2)
15677 delete arg2;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (temp2)
15683 delete arg2;
15684 }
15685 return NULL;
15686 }
15687
15688
15689 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15690 PyObject *resultobj;
15691 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15692 wxString result;
15693 PyObject * obj0 = 0 ;
15694 char *kwnames[] = {
15695 (char *) "self", NULL
15696 };
15697
15698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15700 if (SWIG_arg_fail(1)) SWIG_fail;
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 result = ((wxCommandEvent const *)arg1)->GetString();
15704
15705 wxPyEndAllowThreads(__tstate);
15706 if (PyErr_Occurred()) SWIG_fail;
15707 }
15708 {
15709 #if wxUSE_UNICODE
15710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15711 #else
15712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15713 #endif
15714 }
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj;
15723 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15724 bool result;
15725 PyObject * obj0 = 0 ;
15726 char *kwnames[] = {
15727 (char *) "self", NULL
15728 };
15729
15730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15732 if (SWIG_arg_fail(1)) SWIG_fail;
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15736
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 {
15741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj;
15751 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15752 bool result;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 {
15769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15770 }
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15778 PyObject *resultobj;
15779 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15780 long arg2 ;
15781 PyObject * obj0 = 0 ;
15782 PyObject * obj1 = 0 ;
15783 char *kwnames[] = {
15784 (char *) "self",(char *) "extraLong", NULL
15785 };
15786
15787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15789 if (SWIG_arg_fail(1)) SWIG_fail;
15790 {
15791 arg2 = (long)(SWIG_As_long(obj1));
15792 if (SWIG_arg_fail(2)) SWIG_fail;
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 (arg1)->SetExtraLong(arg2);
15797
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 Py_INCREF(Py_None); resultobj = Py_None;
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj;
15810 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15811 long result;
15812 PyObject * obj0 = 0 ;
15813 char *kwnames[] = {
15814 (char *) "self", NULL
15815 };
15816
15817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15819 if (SWIG_arg_fail(1)) SWIG_fail;
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15823
15824 wxPyEndAllowThreads(__tstate);
15825 if (PyErr_Occurred()) SWIG_fail;
15826 }
15827 {
15828 resultobj = SWIG_From_long((long)(result));
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15837 PyObject *resultobj;
15838 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15839 int arg2 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char *kwnames[] = {
15843 (char *) "self",(char *) "i", NULL
15844 };
15845
15846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, 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)->SetInt(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_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15868 PyObject *resultobj;
15869 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15870 long result;
15871 PyObject * obj0 = 0 ;
15872 char *kwnames[] = {
15873 (char *) "self", NULL
15874 };
15875
15876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15878 if (SWIG_arg_fail(1)) SWIG_fail;
15879 {
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15882
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 {
15887 resultobj = SWIG_From_long((long)(result));
15888 }
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj;
15897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15898 wxEvent *result;
15899 PyObject * obj0 = 0 ;
15900 char *kwnames[] = {
15901 (char *) "self", NULL
15902 };
15903
15904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15906 if (SWIG_arg_fail(1)) SWIG_fail;
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15910
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15922 PyObject *obj;
15923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15924 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15925 Py_INCREF(obj);
15926 return Py_BuildValue((char *)"");
15927 }
15928 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15929 PyObject *resultobj;
15930 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15931 int arg2 = (int) 0 ;
15932 wxNotifyEvent *result;
15933 PyObject * obj0 = 0 ;
15934 PyObject * obj1 = 0 ;
15935 char *kwnames[] = {
15936 (char *) "commandType",(char *) "winid", NULL
15937 };
15938
15939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15940 if (obj0) {
15941 {
15942 arg1 = (wxEventType)(SWIG_As_int(obj0));
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 }
15945 }
15946 if (obj1) {
15947 {
15948 arg2 = (int)(SWIG_As_int(obj1));
15949 if (SWIG_arg_fail(2)) SWIG_fail;
15950 }
15951 }
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15955
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj;
15968 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15969 PyObject * obj0 = 0 ;
15970 char *kwnames[] = {
15971 (char *) "self", NULL
15972 };
15973
15974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15976 if (SWIG_arg_fail(1)) SWIG_fail;
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 (arg1)->Veto();
15980
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 Py_INCREF(Py_None); resultobj = Py_None;
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj;
15993 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15994 PyObject * obj0 = 0 ;
15995 char *kwnames[] = {
15996 (char *) "self", NULL
15997 };
15998
15999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16001 if (SWIG_arg_fail(1)) SWIG_fail;
16002 {
16003 PyThreadState* __tstate = wxPyBeginAllowThreads();
16004 (arg1)->Allow();
16005
16006 wxPyEndAllowThreads(__tstate);
16007 if (PyErr_Occurred()) SWIG_fail;
16008 }
16009 Py_INCREF(Py_None); resultobj = Py_None;
16010 return resultobj;
16011 fail:
16012 return NULL;
16013 }
16014
16015
16016 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16017 PyObject *resultobj;
16018 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16019 bool result;
16020 PyObject * obj0 = 0 ;
16021 char *kwnames[] = {
16022 (char *) "self", NULL
16023 };
16024
16025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16027 if (SWIG_arg_fail(1)) SWIG_fail;
16028 {
16029 PyThreadState* __tstate = wxPyBeginAllowThreads();
16030 result = (bool)(arg1)->IsAllowed();
16031
16032 wxPyEndAllowThreads(__tstate);
16033 if (PyErr_Occurred()) SWIG_fail;
16034 }
16035 {
16036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16037 }
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16045 PyObject *obj;
16046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16047 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16048 Py_INCREF(obj);
16049 return Py_BuildValue((char *)"");
16050 }
16051 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj;
16053 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16054 int arg2 = (int) 0 ;
16055 int arg3 = (int) 0 ;
16056 int arg4 = (int) 0 ;
16057 wxScrollEvent *result;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 PyObject * obj3 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16067 if (obj0) {
16068 {
16069 arg1 = (wxEventType)(SWIG_As_int(obj0));
16070 if (SWIG_arg_fail(1)) SWIG_fail;
16071 }
16072 }
16073 if (obj1) {
16074 {
16075 arg2 = (int)(SWIG_As_int(obj1));
16076 if (SWIG_arg_fail(2)) SWIG_fail;
16077 }
16078 }
16079 if (obj2) {
16080 {
16081 arg3 = (int)(SWIG_As_int(obj2));
16082 if (SWIG_arg_fail(3)) SWIG_fail;
16083 }
16084 }
16085 if (obj3) {
16086 {
16087 arg4 = (int)(SWIG_As_int(obj3));
16088 if (SWIG_arg_fail(4)) SWIG_fail;
16089 }
16090 }
16091 {
16092 PyThreadState* __tstate = wxPyBeginAllowThreads();
16093 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16094
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16099 return resultobj;
16100 fail:
16101 return NULL;
16102 }
16103
16104
16105 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16106 PyObject *resultobj;
16107 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16108 int result;
16109 PyObject * obj0 = 0 ;
16110 char *kwnames[] = {
16111 (char *) "self", NULL
16112 };
16113
16114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16116 if (SWIG_arg_fail(1)) SWIG_fail;
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16120
16121 wxPyEndAllowThreads(__tstate);
16122 if (PyErr_Occurred()) SWIG_fail;
16123 }
16124 {
16125 resultobj = SWIG_From_int((int)(result));
16126 }
16127 return resultobj;
16128 fail:
16129 return NULL;
16130 }
16131
16132
16133 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16134 PyObject *resultobj;
16135 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16136 int result;
16137 PyObject * obj0 = 0 ;
16138 char *kwnames[] = {
16139 (char *) "self", NULL
16140 };
16141
16142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16144 if (SWIG_arg_fail(1)) SWIG_fail;
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16148
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 {
16153 resultobj = SWIG_From_int((int)(result));
16154 }
16155 return resultobj;
16156 fail:
16157 return NULL;
16158 }
16159
16160
16161 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16162 PyObject *resultobj;
16163 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16164 int arg2 ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self",(char *) "orient", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 arg2 = (int)(SWIG_As_int(obj1));
16176 if (SWIG_arg_fail(2)) SWIG_fail;
16177 }
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 (arg1)->SetOrientation(arg2);
16181
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 Py_INCREF(Py_None); resultobj = Py_None;
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj;
16194 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16195 int arg2 ;
16196 PyObject * obj0 = 0 ;
16197 PyObject * obj1 = 0 ;
16198 char *kwnames[] = {
16199 (char *) "self",(char *) "pos", NULL
16200 };
16201
16202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16204 if (SWIG_arg_fail(1)) SWIG_fail;
16205 {
16206 arg2 = (int)(SWIG_As_int(obj1));
16207 if (SWIG_arg_fail(2)) SWIG_fail;
16208 }
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 (arg1)->SetPosition(arg2);
16212
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 Py_INCREF(Py_None); resultobj = Py_None;
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16224 PyObject *obj;
16225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16226 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16227 Py_INCREF(obj);
16228 return Py_BuildValue((char *)"");
16229 }
16230 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj;
16232 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16233 int arg2 = (int) 0 ;
16234 int arg3 = (int) 0 ;
16235 wxScrollWinEvent *result;
16236 PyObject * obj0 = 0 ;
16237 PyObject * obj1 = 0 ;
16238 PyObject * obj2 = 0 ;
16239 char *kwnames[] = {
16240 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16241 };
16242
16243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16244 if (obj0) {
16245 {
16246 arg1 = (wxEventType)(SWIG_As_int(obj0));
16247 if (SWIG_arg_fail(1)) SWIG_fail;
16248 }
16249 }
16250 if (obj1) {
16251 {
16252 arg2 = (int)(SWIG_As_int(obj1));
16253 if (SWIG_arg_fail(2)) SWIG_fail;
16254 }
16255 }
16256 if (obj2) {
16257 {
16258 arg3 = (int)(SWIG_As_int(obj2));
16259 if (SWIG_arg_fail(3)) SWIG_fail;
16260 }
16261 }
16262 {
16263 PyThreadState* __tstate = wxPyBeginAllowThreads();
16264 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16265
16266 wxPyEndAllowThreads(__tstate);
16267 if (PyErr_Occurred()) SWIG_fail;
16268 }
16269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16270 return resultobj;
16271 fail:
16272 return NULL;
16273 }
16274
16275
16276 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16277 PyObject *resultobj;
16278 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16279 int result;
16280 PyObject * obj0 = 0 ;
16281 char *kwnames[] = {
16282 (char *) "self", NULL
16283 };
16284
16285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16287 if (SWIG_arg_fail(1)) SWIG_fail;
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16291
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 {
16296 resultobj = SWIG_From_int((int)(result));
16297 }
16298 return resultobj;
16299 fail:
16300 return NULL;
16301 }
16302
16303
16304 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16305 PyObject *resultobj;
16306 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16307 int result;
16308 PyObject * obj0 = 0 ;
16309 char *kwnames[] = {
16310 (char *) "self", NULL
16311 };
16312
16313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16315 if (SWIG_arg_fail(1)) SWIG_fail;
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16319
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = SWIG_From_int((int)(result));
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj;
16334 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16335 int arg2 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char *kwnames[] = {
16339 (char *) "self",(char *) "orient", NULL
16340 };
16341
16342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16344 if (SWIG_arg_fail(1)) SWIG_fail;
16345 {
16346 arg2 = (int)(SWIG_As_int(obj1));
16347 if (SWIG_arg_fail(2)) SWIG_fail;
16348 }
16349 {
16350 PyThreadState* __tstate = wxPyBeginAllowThreads();
16351 (arg1)->SetOrientation(arg2);
16352
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 Py_INCREF(Py_None); resultobj = Py_None;
16357 return resultobj;
16358 fail:
16359 return NULL;
16360 }
16361
16362
16363 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16364 PyObject *resultobj;
16365 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16366 int arg2 ;
16367 PyObject * obj0 = 0 ;
16368 PyObject * obj1 = 0 ;
16369 char *kwnames[] = {
16370 (char *) "self",(char *) "pos", NULL
16371 };
16372
16373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16375 if (SWIG_arg_fail(1)) SWIG_fail;
16376 {
16377 arg2 = (int)(SWIG_As_int(obj1));
16378 if (SWIG_arg_fail(2)) SWIG_fail;
16379 }
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 (arg1)->SetPosition(arg2);
16383
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 Py_INCREF(Py_None); resultobj = Py_None;
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16395 PyObject *obj;
16396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16397 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16398 Py_INCREF(obj);
16399 return Py_BuildValue((char *)"");
16400 }
16401 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16402 PyObject *resultobj;
16403 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16404 wxMouseEvent *result;
16405 PyObject * obj0 = 0 ;
16406 char *kwnames[] = {
16407 (char *) "mouseType", NULL
16408 };
16409
16410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16411 if (obj0) {
16412 {
16413 arg1 = (wxEventType)(SWIG_As_int(obj0));
16414 if (SWIG_arg_fail(1)) SWIG_fail;
16415 }
16416 }
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 resultobj = wxPyMake_wxObject(result, 1);
16426 }
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj;
16435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16436 bool result;
16437 PyObject * obj0 = 0 ;
16438 char *kwnames[] = {
16439 (char *) "self", NULL
16440 };
16441
16442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16444 if (SWIG_arg_fail(1)) SWIG_fail;
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16448
16449 wxPyEndAllowThreads(__tstate);
16450 if (PyErr_Occurred()) SWIG_fail;
16451 }
16452 {
16453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16454 }
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj;
16463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16464 int arg2 = (int) wxMOUSE_BTN_ANY ;
16465 bool result;
16466 PyObject * obj0 = 0 ;
16467 PyObject * obj1 = 0 ;
16468 char *kwnames[] = {
16469 (char *) "self",(char *) "but", NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16474 if (SWIG_arg_fail(1)) SWIG_fail;
16475 if (obj1) {
16476 {
16477 arg2 = (int)(SWIG_As_int(obj1));
16478 if (SWIG_arg_fail(2)) SWIG_fail;
16479 }
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16484
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 {
16489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16490 }
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj;
16499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16500 int arg2 = (int) wxMOUSE_BTN_ANY ;
16501 bool result;
16502 PyObject * obj0 = 0 ;
16503 PyObject * obj1 = 0 ;
16504 char *kwnames[] = {
16505 (char *) "self",(char *) "but", NULL
16506 };
16507
16508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16510 if (SWIG_arg_fail(1)) SWIG_fail;
16511 if (obj1) {
16512 {
16513 arg2 = (int)(SWIG_As_int(obj1));
16514 if (SWIG_arg_fail(2)) SWIG_fail;
16515 }
16516 }
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
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_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16536 int arg2 = (int) wxMOUSE_BTN_ANY ;
16537 bool result;
16538 PyObject * obj0 = 0 ;
16539 PyObject * obj1 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self",(char *) "but", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 if (obj1) {
16548 {
16549 arg2 = (int)(SWIG_As_int(obj1));
16550 if (SWIG_arg_fail(2)) SWIG_fail;
16551 }
16552 }
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 {
16561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16562 }
16563 return resultobj;
16564 fail:
16565 return NULL;
16566 }
16567
16568
16569 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16570 PyObject *resultobj;
16571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16572 int arg2 ;
16573 bool result;
16574 PyObject * obj0 = 0 ;
16575 PyObject * obj1 = 0 ;
16576 char *kwnames[] = {
16577 (char *) "self",(char *) "but", NULL
16578 };
16579
16580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 {
16584 arg2 = (int)(SWIG_As_int(obj1));
16585 if (SWIG_arg_fail(2)) SWIG_fail;
16586 }
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16590
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 {
16595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16596 }
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16604 PyObject *resultobj;
16605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16606 int arg2 ;
16607 bool result;
16608 PyObject * obj0 = 0 ;
16609 PyObject * obj1 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "self",(char *) "but", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16616 if (SWIG_arg_fail(1)) SWIG_fail;
16617 {
16618 arg2 = (int)(SWIG_As_int(obj1));
16619 if (SWIG_arg_fail(2)) SWIG_fail;
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16624
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16630 }
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj;
16639 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16640 int result;
16641 PyObject * obj0 = 0 ;
16642 char *kwnames[] = {
16643 (char *) "self", NULL
16644 };
16645
16646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16648 if (SWIG_arg_fail(1)) SWIG_fail;
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 {
16657 resultobj = SWIG_From_int((int)(result));
16658 }
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16666 PyObject *resultobj;
16667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16668 bool result;
16669 PyObject * obj0 = 0 ;
16670 char *kwnames[] = {
16671 (char *) "self", NULL
16672 };
16673
16674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16676 if (SWIG_arg_fail(1)) SWIG_fail;
16677 {
16678 PyThreadState* __tstate = wxPyBeginAllowThreads();
16679 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16680
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 {
16685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16686 }
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj;
16695 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16696 bool result;
16697 PyObject * obj0 = 0 ;
16698 char *kwnames[] = {
16699 (char *) "self", NULL
16700 };
16701
16702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16704 if (SWIG_arg_fail(1)) SWIG_fail;
16705 {
16706 PyThreadState* __tstate = wxPyBeginAllowThreads();
16707 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16708
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 {
16713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16714 }
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj;
16723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16724 bool result;
16725 PyObject * obj0 = 0 ;
16726 char *kwnames[] = {
16727 (char *) "self", NULL
16728 };
16729
16730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16732 if (SWIG_arg_fail(1)) SWIG_fail;
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 {
16741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16742 }
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16752 bool result;
16753 PyObject * obj0 = 0 ;
16754 char *kwnames[] = {
16755 (char *) "self", NULL
16756 };
16757
16758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16760 if (SWIG_arg_fail(1)) SWIG_fail;
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16764
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16770 }
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj;
16779 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16780 bool result;
16781 PyObject * obj0 = 0 ;
16782 char *kwnames[] = {
16783 (char *) "self", NULL
16784 };
16785
16786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16788 if (SWIG_arg_fail(1)) SWIG_fail;
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16792
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 {
16797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16798 }
16799 return resultobj;
16800 fail:
16801 return NULL;
16802 }
16803
16804
16805 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16806 PyObject *resultobj;
16807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16808 bool result;
16809 PyObject * obj0 = 0 ;
16810 char *kwnames[] = {
16811 (char *) "self", NULL
16812 };
16813
16814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16816 if (SWIG_arg_fail(1)) SWIG_fail;
16817 {
16818 PyThreadState* __tstate = wxPyBeginAllowThreads();
16819 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16820
16821 wxPyEndAllowThreads(__tstate);
16822 if (PyErr_Occurred()) SWIG_fail;
16823 }
16824 {
16825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16826 }
16827 return resultobj;
16828 fail:
16829 return NULL;
16830 }
16831
16832
16833 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16834 PyObject *resultobj;
16835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16836 bool result;
16837 PyObject * obj0 = 0 ;
16838 char *kwnames[] = {
16839 (char *) "self", NULL
16840 };
16841
16842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16844 if (SWIG_arg_fail(1)) SWIG_fail;
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16862 PyObject *resultobj;
16863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16864 bool result;
16865 PyObject * obj0 = 0 ;
16866 char *kwnames[] = {
16867 (char *) "self", NULL
16868 };
16869
16870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16872 if (SWIG_arg_fail(1)) SWIG_fail;
16873 {
16874 PyThreadState* __tstate = wxPyBeginAllowThreads();
16875 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16876
16877 wxPyEndAllowThreads(__tstate);
16878 if (PyErr_Occurred()) SWIG_fail;
16879 }
16880 {
16881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16882 }
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16890 PyObject *resultobj;
16891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16892 bool result;
16893 PyObject * obj0 = 0 ;
16894 char *kwnames[] = {
16895 (char *) "self", NULL
16896 };
16897
16898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16900 if (SWIG_arg_fail(1)) SWIG_fail;
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16904
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 {
16909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16910 }
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj;
16919 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16920 bool result;
16921 PyObject * obj0 = 0 ;
16922 char *kwnames[] = {
16923 (char *) "self", NULL
16924 };
16925
16926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16928 if (SWIG_arg_fail(1)) SWIG_fail;
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 {
16937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16938 }
16939 return resultobj;
16940 fail:
16941 return NULL;
16942 }
16943
16944
16945 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16946 PyObject *resultobj;
16947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16948 bool result;
16949 PyObject * obj0 = 0 ;
16950 char *kwnames[] = {
16951 (char *) "self", NULL
16952 };
16953
16954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16956 if (SWIG_arg_fail(1)) SWIG_fail;
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16960
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 {
16965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16966 }
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16976 bool result;
16977 PyObject * obj0 = 0 ;
16978 char *kwnames[] = {
16979 (char *) "self", NULL
16980 };
16981
16982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16984 if (SWIG_arg_fail(1)) SWIG_fail;
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 {
16993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16994 }
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17002 PyObject *resultobj;
17003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17004 bool result;
17005 PyObject * obj0 = 0 ;
17006 char *kwnames[] = {
17007 (char *) "self", NULL
17008 };
17009
17010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17012 if (SWIG_arg_fail(1)) SWIG_fail;
17013 {
17014 PyThreadState* __tstate = wxPyBeginAllowThreads();
17015 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17016
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 {
17021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17022 }
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj;
17031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17032 bool result;
17033 PyObject * obj0 = 0 ;
17034 char *kwnames[] = {
17035 (char *) "self", NULL
17036 };
17037
17038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17040 if (SWIG_arg_fail(1)) SWIG_fail;
17041 {
17042 PyThreadState* __tstate = wxPyBeginAllowThreads();
17043 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17044
17045 wxPyEndAllowThreads(__tstate);
17046 if (PyErr_Occurred()) SWIG_fail;
17047 }
17048 {
17049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17050 }
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj;
17059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17060 bool result;
17061 PyObject * obj0 = 0 ;
17062 char *kwnames[] = {
17063 (char *) "self", NULL
17064 };
17065
17066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17068 if (SWIG_arg_fail(1)) SWIG_fail;
17069 {
17070 PyThreadState* __tstate = wxPyBeginAllowThreads();
17071 result = (bool)(arg1)->LeftIsDown();
17072
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 {
17077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17088 bool result;
17089 PyObject * obj0 = 0 ;
17090 char *kwnames[] = {
17091 (char *) "self", NULL
17092 };
17093
17094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17096 if (SWIG_arg_fail(1)) SWIG_fail;
17097 {
17098 PyThreadState* __tstate = wxPyBeginAllowThreads();
17099 result = (bool)(arg1)->MiddleIsDown();
17100
17101 wxPyEndAllowThreads(__tstate);
17102 if (PyErr_Occurred()) SWIG_fail;
17103 }
17104 {
17105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj;
17115 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17116 bool result;
17117 PyObject * obj0 = 0 ;
17118 char *kwnames[] = {
17119 (char *) "self", NULL
17120 };
17121
17122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17124 if (SWIG_arg_fail(1)) SWIG_fail;
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (bool)(arg1)->RightIsDown();
17128
17129 wxPyEndAllowThreads(__tstate);
17130 if (PyErr_Occurred()) SWIG_fail;
17131 }
17132 {
17133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17134 }
17135 return resultobj;
17136 fail:
17137 return NULL;
17138 }
17139
17140
17141 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17142 PyObject *resultobj;
17143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17144 bool result;
17145 PyObject * obj0 = 0 ;
17146 char *kwnames[] = {
17147 (char *) "self", NULL
17148 };
17149
17150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17152 if (SWIG_arg_fail(1)) SWIG_fail;
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17156
17157 wxPyEndAllowThreads(__tstate);
17158 if (PyErr_Occurred()) SWIG_fail;
17159 }
17160 {
17161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17162 }
17163 return resultobj;
17164 fail:
17165 return NULL;
17166 }
17167
17168
17169 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17170 PyObject *resultobj;
17171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17172 bool result;
17173 PyObject * obj0 = 0 ;
17174 char *kwnames[] = {
17175 (char *) "self", NULL
17176 };
17177
17178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17180 if (SWIG_arg_fail(1)) SWIG_fail;
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17184
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 {
17189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17190 }
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj;
17199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17200 bool result;
17201 PyObject * obj0 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17218 }
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj;
17227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17228 bool result;
17229 PyObject * obj0 = 0 ;
17230 char *kwnames[] = {
17231 (char *) "self", NULL
17232 };
17233
17234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17236 if (SWIG_arg_fail(1)) SWIG_fail;
17237 {
17238 PyThreadState* __tstate = wxPyBeginAllowThreads();
17239 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17240
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17246 }
17247 return resultobj;
17248 fail:
17249 return NULL;
17250 }
17251
17252
17253 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj;
17255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17256 wxPoint result;
17257 PyObject * obj0 = 0 ;
17258 char *kwnames[] = {
17259 (char *) "self", NULL
17260 };
17261
17262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17264 if (SWIG_arg_fail(1)) SWIG_fail;
17265 {
17266 PyThreadState* __tstate = wxPyBeginAllowThreads();
17267 result = (arg1)->GetPosition();
17268
17269 wxPyEndAllowThreads(__tstate);
17270 if (PyErr_Occurred()) SWIG_fail;
17271 }
17272 {
17273 wxPoint * resultptr;
17274 resultptr = new wxPoint((wxPoint &)(result));
17275 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17276 }
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj;
17285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17286 long *arg2 = (long *) 0 ;
17287 long *arg3 = (long *) 0 ;
17288 long temp2 ;
17289 int res2 = 0 ;
17290 long temp3 ;
17291 int res3 = 0 ;
17292 PyObject * obj0 = 0 ;
17293 char *kwnames[] = {
17294 (char *) "self", NULL
17295 };
17296
17297 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17298 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17301 if (SWIG_arg_fail(1)) SWIG_fail;
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 (arg1)->GetPosition(arg2,arg3);
17305
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 Py_INCREF(Py_None); resultobj = Py_None;
17310 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17311 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17312 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17313 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17314 return resultobj;
17315 fail:
17316 return NULL;
17317 }
17318
17319
17320 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17321 PyObject *resultobj;
17322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17323 wxDC *arg2 = 0 ;
17324 wxPoint result;
17325 PyObject * obj0 = 0 ;
17326 PyObject * obj1 = 0 ;
17327 char *kwnames[] = {
17328 (char *) "self",(char *) "dc", NULL
17329 };
17330
17331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17333 if (SWIG_arg_fail(1)) SWIG_fail;
17334 {
17335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17336 if (SWIG_arg_fail(2)) SWIG_fail;
17337 if (arg2 == NULL) {
17338 SWIG_null_ref("wxDC");
17339 }
17340 if (SWIG_arg_fail(2)) SWIG_fail;
17341 }
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17345
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 {
17350 wxPoint * resultptr;
17351 resultptr = new wxPoint((wxPoint &)(result));
17352 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17353 }
17354 return resultobj;
17355 fail:
17356 return NULL;
17357 }
17358
17359
17360 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17361 PyObject *resultobj;
17362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17363 int result;
17364 PyObject * obj0 = 0 ;
17365 char *kwnames[] = {
17366 (char *) "self", NULL
17367 };
17368
17369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17371 if (SWIG_arg_fail(1)) SWIG_fail;
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (int)((wxMouseEvent const *)arg1)->GetX();
17375
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = SWIG_From_int((int)(result));
17381 }
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj;
17390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17391 int result;
17392 PyObject * obj0 = 0 ;
17393 char *kwnames[] = {
17394 (char *) "self", NULL
17395 };
17396
17397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17399 if (SWIG_arg_fail(1)) SWIG_fail;
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (int)((wxMouseEvent const *)arg1)->GetY();
17403
17404 wxPyEndAllowThreads(__tstate);
17405 if (PyErr_Occurred()) SWIG_fail;
17406 }
17407 {
17408 resultobj = SWIG_From_int((int)(result));
17409 }
17410 return resultobj;
17411 fail:
17412 return NULL;
17413 }
17414
17415
17416 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17417 PyObject *resultobj;
17418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17419 int result;
17420 PyObject * obj0 = 0 ;
17421 char *kwnames[] = {
17422 (char *) "self", NULL
17423 };
17424
17425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17427 if (SWIG_arg_fail(1)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 {
17436 resultobj = SWIG_From_int((int)(result));
17437 }
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj;
17446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17447 int result;
17448 PyObject * obj0 = 0 ;
17449 char *kwnames[] = {
17450 (char *) "self", NULL
17451 };
17452
17453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17455 if (SWIG_arg_fail(1)) SWIG_fail;
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = SWIG_From_int((int)(result));
17465 }
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj;
17474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17475 int result;
17476 PyObject * obj0 = 0 ;
17477 char *kwnames[] = {
17478 (char *) "self", NULL
17479 };
17480
17481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17483 if (SWIG_arg_fail(1)) SWIG_fail;
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17487
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 {
17492 resultobj = SWIG_From_int((int)(result));
17493 }
17494 return resultobj;
17495 fail:
17496 return NULL;
17497 }
17498
17499
17500 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj;
17502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17503 bool result;
17504 PyObject * obj0 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17515
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 {
17520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17521 }
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17529 PyObject *resultobj;
17530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17531 int arg2 ;
17532 PyObject * obj0 = 0 ;
17533 PyObject * obj1 = 0 ;
17534 char *kwnames[] = {
17535 (char *) "self",(char *) "m_x", NULL
17536 };
17537
17538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17540 if (SWIG_arg_fail(1)) SWIG_fail;
17541 {
17542 arg2 = (int)(SWIG_As_int(obj1));
17543 if (SWIG_arg_fail(2)) SWIG_fail;
17544 }
17545 if (arg1) (arg1)->m_x = arg2;
17546
17547 Py_INCREF(Py_None); resultobj = Py_None;
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj;
17556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17557 int result;
17558 PyObject * obj0 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 result = (int) ((arg1)->m_x);
17567
17568 {
17569 resultobj = SWIG_From_int((int)(result));
17570 }
17571 return resultobj;
17572 fail:
17573 return NULL;
17574 }
17575
17576
17577 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17578 PyObject *resultobj;
17579 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17580 int arg2 ;
17581 PyObject * obj0 = 0 ;
17582 PyObject * obj1 = 0 ;
17583 char *kwnames[] = {
17584 (char *) "self",(char *) "m_y", NULL
17585 };
17586
17587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17589 if (SWIG_arg_fail(1)) SWIG_fail;
17590 {
17591 arg2 = (int)(SWIG_As_int(obj1));
17592 if (SWIG_arg_fail(2)) SWIG_fail;
17593 }
17594 if (arg1) (arg1)->m_y = arg2;
17595
17596 Py_INCREF(Py_None); resultobj = Py_None;
17597 return resultobj;
17598 fail:
17599 return NULL;
17600 }
17601
17602
17603 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17604 PyObject *resultobj;
17605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17606 int result;
17607 PyObject * obj0 = 0 ;
17608 char *kwnames[] = {
17609 (char *) "self", NULL
17610 };
17611
17612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17614 if (SWIG_arg_fail(1)) SWIG_fail;
17615 result = (int) ((arg1)->m_y);
17616
17617 {
17618 resultobj = SWIG_From_int((int)(result));
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17629 bool arg2 ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 char *kwnames[] = {
17633 (char *) "self",(char *) "m_leftDown", NULL
17634 };
17635
17636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17638 if (SWIG_arg_fail(1)) SWIG_fail;
17639 {
17640 arg2 = (bool)(SWIG_As_bool(obj1));
17641 if (SWIG_arg_fail(2)) SWIG_fail;
17642 }
17643 if (arg1) (arg1)->m_leftDown = arg2;
17644
17645 Py_INCREF(Py_None); resultobj = Py_None;
17646 return resultobj;
17647 fail:
17648 return NULL;
17649 }
17650
17651
17652 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17653 PyObject *resultobj;
17654 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17655 bool result;
17656 PyObject * obj0 = 0 ;
17657 char *kwnames[] = {
17658 (char *) "self", NULL
17659 };
17660
17661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17663 if (SWIG_arg_fail(1)) SWIG_fail;
17664 result = (bool) ((arg1)->m_leftDown);
17665
17666 {
17667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17668 }
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj;
17677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17678 bool arg2 ;
17679 PyObject * obj0 = 0 ;
17680 PyObject * obj1 = 0 ;
17681 char *kwnames[] = {
17682 (char *) "self",(char *) "m_middleDown", NULL
17683 };
17684
17685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17687 if (SWIG_arg_fail(1)) SWIG_fail;
17688 {
17689 arg2 = (bool)(SWIG_As_bool(obj1));
17690 if (SWIG_arg_fail(2)) SWIG_fail;
17691 }
17692 if (arg1) (arg1)->m_middleDown = arg2;
17693
17694 Py_INCREF(Py_None); resultobj = Py_None;
17695 return resultobj;
17696 fail:
17697 return NULL;
17698 }
17699
17700
17701 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17702 PyObject *resultobj;
17703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17704 bool result;
17705 PyObject * obj0 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 result = (bool) ((arg1)->m_middleDown);
17714
17715 {
17716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17717 }
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj;
17726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17727 bool arg2 ;
17728 PyObject * obj0 = 0 ;
17729 PyObject * obj1 = 0 ;
17730 char *kwnames[] = {
17731 (char *) "self",(char *) "m_rightDown", NULL
17732 };
17733
17734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17736 if (SWIG_arg_fail(1)) SWIG_fail;
17737 {
17738 arg2 = (bool)(SWIG_As_bool(obj1));
17739 if (SWIG_arg_fail(2)) SWIG_fail;
17740 }
17741 if (arg1) (arg1)->m_rightDown = arg2;
17742
17743 Py_INCREF(Py_None); resultobj = Py_None;
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj;
17752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17753 bool result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "self", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 result = (bool) ((arg1)->m_rightDown);
17763
17764 {
17765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17766 }
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj;
17775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17776 bool arg2 ;
17777 PyObject * obj0 = 0 ;
17778 PyObject * obj1 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "self",(char *) "m_controlDown", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 arg2 = (bool)(SWIG_As_bool(obj1));
17788 if (SWIG_arg_fail(2)) SWIG_fail;
17789 }
17790 if (arg1) (arg1)->m_controlDown = arg2;
17791
17792 Py_INCREF(Py_None); resultobj = Py_None;
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17800 PyObject *resultobj;
17801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17802 bool result;
17803 PyObject * obj0 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "self", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 result = (bool) ((arg1)->m_controlDown);
17812
17813 {
17814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17815 }
17816 return resultobj;
17817 fail:
17818 return NULL;
17819 }
17820
17821
17822 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17823 PyObject *resultobj;
17824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17825 bool arg2 ;
17826 PyObject * obj0 = 0 ;
17827 PyObject * obj1 = 0 ;
17828 char *kwnames[] = {
17829 (char *) "self",(char *) "m_shiftDown", NULL
17830 };
17831
17832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17834 if (SWIG_arg_fail(1)) SWIG_fail;
17835 {
17836 arg2 = (bool)(SWIG_As_bool(obj1));
17837 if (SWIG_arg_fail(2)) SWIG_fail;
17838 }
17839 if (arg1) (arg1)->m_shiftDown = arg2;
17840
17841 Py_INCREF(Py_None); resultobj = Py_None;
17842 return resultobj;
17843 fail:
17844 return NULL;
17845 }
17846
17847
17848 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17849 PyObject *resultobj;
17850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17851 bool result;
17852 PyObject * obj0 = 0 ;
17853 char *kwnames[] = {
17854 (char *) "self", NULL
17855 };
17856
17857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17859 if (SWIG_arg_fail(1)) SWIG_fail;
17860 result = (bool) ((arg1)->m_shiftDown);
17861
17862 {
17863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17872 PyObject *resultobj;
17873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17874 bool arg2 ;
17875 PyObject * obj0 = 0 ;
17876 PyObject * obj1 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "self",(char *) "m_altDown", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(1)) SWIG_fail;
17884 {
17885 arg2 = (bool)(SWIG_As_bool(obj1));
17886 if (SWIG_arg_fail(2)) SWIG_fail;
17887 }
17888 if (arg1) (arg1)->m_altDown = arg2;
17889
17890 Py_INCREF(Py_None); resultobj = Py_None;
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj;
17899 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17900 bool result;
17901 PyObject * obj0 = 0 ;
17902 char *kwnames[] = {
17903 (char *) "self", NULL
17904 };
17905
17906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17908 if (SWIG_arg_fail(1)) SWIG_fail;
17909 result = (bool) ((arg1)->m_altDown);
17910
17911 {
17912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17913 }
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17923 bool arg2 ;
17924 PyObject * obj0 = 0 ;
17925 PyObject * obj1 = 0 ;
17926 char *kwnames[] = {
17927 (char *) "self",(char *) "m_metaDown", NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17932 if (SWIG_arg_fail(1)) SWIG_fail;
17933 {
17934 arg2 = (bool)(SWIG_As_bool(obj1));
17935 if (SWIG_arg_fail(2)) SWIG_fail;
17936 }
17937 if (arg1) (arg1)->m_metaDown = arg2;
17938
17939 Py_INCREF(Py_None); resultobj = Py_None;
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj;
17948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17949 bool result;
17950 PyObject * obj0 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 result = (bool) ((arg1)->m_metaDown);
17959
17960 {
17961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17962 }
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17972 int arg2 ;
17973 PyObject * obj0 = 0 ;
17974 PyObject * obj1 = 0 ;
17975 char *kwnames[] = {
17976 (char *) "self",(char *) "m_wheelRotation", NULL
17977 };
17978
17979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17981 if (SWIG_arg_fail(1)) SWIG_fail;
17982 {
17983 arg2 = (int)(SWIG_As_int(obj1));
17984 if (SWIG_arg_fail(2)) SWIG_fail;
17985 }
17986 if (arg1) (arg1)->m_wheelRotation = arg2;
17987
17988 Py_INCREF(Py_None); resultobj = Py_None;
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17998 int result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 result = (int) ((arg1)->m_wheelRotation);
18008
18009 {
18010 resultobj = SWIG_From_int((int)(result));
18011 }
18012 return resultobj;
18013 fail:
18014 return NULL;
18015 }
18016
18017
18018 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18019 PyObject *resultobj;
18020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18021 int arg2 ;
18022 PyObject * obj0 = 0 ;
18023 PyObject * obj1 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self",(char *) "m_wheelDelta", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 arg2 = (int)(SWIG_As_int(obj1));
18033 if (SWIG_arg_fail(2)) SWIG_fail;
18034 }
18035 if (arg1) (arg1)->m_wheelDelta = arg2;
18036
18037 Py_INCREF(Py_None); resultobj = Py_None;
18038 return resultobj;
18039 fail:
18040 return NULL;
18041 }
18042
18043
18044 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18045 PyObject *resultobj;
18046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18047 int result;
18048 PyObject * obj0 = 0 ;
18049 char *kwnames[] = {
18050 (char *) "self", NULL
18051 };
18052
18053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18055 if (SWIG_arg_fail(1)) SWIG_fail;
18056 result = (int) ((arg1)->m_wheelDelta);
18057
18058 {
18059 resultobj = SWIG_From_int((int)(result));
18060 }
18061 return resultobj;
18062 fail:
18063 return NULL;
18064 }
18065
18066
18067 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18068 PyObject *resultobj;
18069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18070 int arg2 ;
18071 PyObject * obj0 = 0 ;
18072 PyObject * obj1 = 0 ;
18073 char *kwnames[] = {
18074 (char *) "self",(char *) "m_linesPerAction", NULL
18075 };
18076
18077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18079 if (SWIG_arg_fail(1)) SWIG_fail;
18080 {
18081 arg2 = (int)(SWIG_As_int(obj1));
18082 if (SWIG_arg_fail(2)) SWIG_fail;
18083 }
18084 if (arg1) (arg1)->m_linesPerAction = arg2;
18085
18086 Py_INCREF(Py_None); resultobj = Py_None;
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj;
18095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18096 int result;
18097 PyObject * obj0 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 result = (int) ((arg1)->m_linesPerAction);
18106
18107 {
18108 resultobj = SWIG_From_int((int)(result));
18109 }
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18117 PyObject *obj;
18118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18119 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18120 Py_INCREF(obj);
18121 return Py_BuildValue((char *)"");
18122 }
18123 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18124 PyObject *resultobj;
18125 int arg1 = (int) 0 ;
18126 int arg2 = (int) 0 ;
18127 wxSetCursorEvent *result;
18128 PyObject * obj0 = 0 ;
18129 PyObject * obj1 = 0 ;
18130 char *kwnames[] = {
18131 (char *) "x",(char *) "y", NULL
18132 };
18133
18134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18135 if (obj0) {
18136 {
18137 arg1 = (int)(SWIG_As_int(obj0));
18138 if (SWIG_arg_fail(1)) SWIG_fail;
18139 }
18140 }
18141 if (obj1) {
18142 {
18143 arg2 = (int)(SWIG_As_int(obj1));
18144 if (SWIG_arg_fail(2)) SWIG_fail;
18145 }
18146 }
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18150
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18164 int result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 resultobj = SWIG_From_int((int)(result));
18182 }
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18192 int result;
18193 PyObject * obj0 = 0 ;
18194 char *kwnames[] = {
18195 (char *) "self", NULL
18196 };
18197
18198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18200 if (SWIG_arg_fail(1)) SWIG_fail;
18201 {
18202 PyThreadState* __tstate = wxPyBeginAllowThreads();
18203 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18204
18205 wxPyEndAllowThreads(__tstate);
18206 if (PyErr_Occurred()) SWIG_fail;
18207 }
18208 {
18209 resultobj = SWIG_From_int((int)(result));
18210 }
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18218 PyObject *resultobj;
18219 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18220 wxCursor *arg2 = 0 ;
18221 PyObject * obj0 = 0 ;
18222 PyObject * obj1 = 0 ;
18223 char *kwnames[] = {
18224 (char *) "self",(char *) "cursor", NULL
18225 };
18226
18227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18229 if (SWIG_arg_fail(1)) SWIG_fail;
18230 {
18231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(2)) SWIG_fail;
18233 if (arg2 == NULL) {
18234 SWIG_null_ref("wxCursor");
18235 }
18236 if (SWIG_arg_fail(2)) SWIG_fail;
18237 }
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 (arg1)->SetCursor((wxCursor const &)*arg2);
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 Py_INCREF(Py_None); resultobj = Py_None;
18246 return resultobj;
18247 fail:
18248 return NULL;
18249 }
18250
18251
18252 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18253 PyObject *resultobj;
18254 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18255 wxCursor *result;
18256 PyObject * obj0 = 0 ;
18257 char *kwnames[] = {
18258 (char *) "self", NULL
18259 };
18260
18261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18263 if (SWIG_arg_fail(1)) SWIG_fail;
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 {
18267 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18268 result = (wxCursor *) &_result_ref;
18269 }
18270
18271 wxPyEndAllowThreads(__tstate);
18272 if (PyErr_Occurred()) SWIG_fail;
18273 }
18274 {
18275 wxCursor* resultptr = new wxCursor(*result);
18276 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18277 }
18278 return resultobj;
18279 fail:
18280 return NULL;
18281 }
18282
18283
18284 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj;
18286 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18287 bool result;
18288 PyObject * obj0 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 {
18297 PyThreadState* __tstate = wxPyBeginAllowThreads();
18298 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18299
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 {
18304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18305 }
18306 return resultobj;
18307 fail:
18308 return NULL;
18309 }
18310
18311
18312 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18313 PyObject *obj;
18314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18315 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18316 Py_INCREF(obj);
18317 return Py_BuildValue((char *)"");
18318 }
18319 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18320 PyObject *resultobj;
18321 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18322 wxKeyEvent *result;
18323 PyObject * obj0 = 0 ;
18324 char *kwnames[] = {
18325 (char *) "keyType", NULL
18326 };
18327
18328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18329 if (obj0) {
18330 {
18331 arg1 = (wxEventType)(SWIG_As_int(obj0));
18332 if (SWIG_arg_fail(1)) SWIG_fail;
18333 }
18334 }
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18338
18339 wxPyEndAllowThreads(__tstate);
18340 if (PyErr_Occurred()) SWIG_fail;
18341 }
18342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18350 PyObject *resultobj;
18351 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18352 bool result;
18353 PyObject * obj0 = 0 ;
18354 char *kwnames[] = {
18355 (char *) "self", NULL
18356 };
18357
18358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18360 if (SWIG_arg_fail(1)) SWIG_fail;
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18364
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 {
18369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18370 }
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18378 PyObject *resultobj;
18379 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18380 bool result;
18381 PyObject * obj0 = 0 ;
18382 char *kwnames[] = {
18383 (char *) "self", NULL
18384 };
18385
18386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18388 if (SWIG_arg_fail(1)) SWIG_fail;
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18408 bool result;
18409 PyObject * obj0 = 0 ;
18410 char *kwnames[] = {
18411 (char *) "self", NULL
18412 };
18413
18414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(1)) SWIG_fail;
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18420
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 {
18425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18426 }
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj;
18435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18436 bool result;
18437 PyObject * obj0 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18448
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18464 bool result;
18465 PyObject * obj0 = 0 ;
18466 char *kwnames[] = {
18467 (char *) "self", NULL
18468 };
18469
18470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18472 if (SWIG_arg_fail(1)) SWIG_fail;
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18476
18477 wxPyEndAllowThreads(__tstate);
18478 if (PyErr_Occurred()) SWIG_fail;
18479 }
18480 {
18481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18482 }
18483 return resultobj;
18484 fail:
18485 return NULL;
18486 }
18487
18488
18489 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj;
18491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18492 bool result;
18493 PyObject * obj0 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18504
18505 wxPyEndAllowThreads(__tstate);
18506 if (PyErr_Occurred()) SWIG_fail;
18507 }
18508 {
18509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18510 }
18511 return resultobj;
18512 fail:
18513 return NULL;
18514 }
18515
18516
18517 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18518 PyObject *resultobj;
18519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18520 int result;
18521 PyObject * obj0 = 0 ;
18522 char *kwnames[] = {
18523 (char *) "self", NULL
18524 };
18525
18526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18528 if (SWIG_arg_fail(1)) SWIG_fail;
18529 {
18530 PyThreadState* __tstate = wxPyBeginAllowThreads();
18531 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18532
18533 wxPyEndAllowThreads(__tstate);
18534 if (PyErr_Occurred()) SWIG_fail;
18535 }
18536 {
18537 resultobj = SWIG_From_int((int)(result));
18538 }
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18546 PyObject *resultobj;
18547 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18548 int result;
18549 PyObject * obj0 = 0 ;
18550 char *kwnames[] = {
18551 (char *) "self", NULL
18552 };
18553
18554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18556 if (SWIG_arg_fail(1)) SWIG_fail;
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18560
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 {
18565 resultobj = SWIG_From_int((int)(result));
18566 }
18567 return resultobj;
18568 fail:
18569 return NULL;
18570 }
18571
18572
18573 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18574 PyObject *resultobj;
18575 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18576 unsigned int result;
18577 PyObject * obj0 = 0 ;
18578 char *kwnames[] = {
18579 (char *) "self", NULL
18580 };
18581
18582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18584 if (SWIG_arg_fail(1)) SWIG_fail;
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 {
18593 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18594 }
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18604 unsigned int result;
18605 PyObject * obj0 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18616
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj;
18631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18632 wxPoint result;
18633 PyObject * obj0 = 0 ;
18634 char *kwnames[] = {
18635 (char *) "self", NULL
18636 };
18637
18638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18640 if (SWIG_arg_fail(1)) SWIG_fail;
18641 {
18642 PyThreadState* __tstate = wxPyBeginAllowThreads();
18643 result = (arg1)->GetPosition();
18644
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 {
18649 wxPoint * resultptr;
18650 resultptr = new wxPoint((wxPoint &)(result));
18651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18652 }
18653 return resultobj;
18654 fail:
18655 return NULL;
18656 }
18657
18658
18659 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18660 PyObject *resultobj;
18661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18662 long *arg2 = (long *) 0 ;
18663 long *arg3 = (long *) 0 ;
18664 long temp2 ;
18665 int res2 = 0 ;
18666 long temp3 ;
18667 int res3 = 0 ;
18668 PyObject * obj0 = 0 ;
18669 char *kwnames[] = {
18670 (char *) "self", NULL
18671 };
18672
18673 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18674 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18677 if (SWIG_arg_fail(1)) SWIG_fail;
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 (arg1)->GetPosition(arg2,arg3);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 Py_INCREF(Py_None); resultobj = Py_None;
18686 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18687 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18688 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18689 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18699 int result;
18700 PyObject * obj0 = 0 ;
18701 char *kwnames[] = {
18702 (char *) "self", NULL
18703 };
18704
18705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18707 if (SWIG_arg_fail(1)) SWIG_fail;
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (int)((wxKeyEvent const *)arg1)->GetX();
18711
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 {
18716 resultobj = SWIG_From_int((int)(result));
18717 }
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj;
18726 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18727 int result;
18728 PyObject * obj0 = 0 ;
18729 char *kwnames[] = {
18730 (char *) "self", NULL
18731 };
18732
18733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18735 if (SWIG_arg_fail(1)) SWIG_fail;
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (int)((wxKeyEvent const *)arg1)->GetY();
18739
18740 wxPyEndAllowThreads(__tstate);
18741 if (PyErr_Occurred()) SWIG_fail;
18742 }
18743 {
18744 resultobj = SWIG_From_int((int)(result));
18745 }
18746 return resultobj;
18747 fail:
18748 return NULL;
18749 }
18750
18751
18752 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18753 PyObject *resultobj;
18754 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18755 int arg2 ;
18756 PyObject * obj0 = 0 ;
18757 PyObject * obj1 = 0 ;
18758 char *kwnames[] = {
18759 (char *) "self",(char *) "m_x", NULL
18760 };
18761
18762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18764 if (SWIG_arg_fail(1)) SWIG_fail;
18765 {
18766 arg2 = (int)(SWIG_As_int(obj1));
18767 if (SWIG_arg_fail(2)) SWIG_fail;
18768 }
18769 if (arg1) (arg1)->m_x = arg2;
18770
18771 Py_INCREF(Py_None); resultobj = Py_None;
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18781 int result;
18782 PyObject * obj0 = 0 ;
18783 char *kwnames[] = {
18784 (char *) "self", NULL
18785 };
18786
18787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18789 if (SWIG_arg_fail(1)) SWIG_fail;
18790 result = (int) ((arg1)->m_x);
18791
18792 {
18793 resultobj = SWIG_From_int((int)(result));
18794 }
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj;
18803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18804 int arg2 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self",(char *) "m_y", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 {
18815 arg2 = (int)(SWIG_As_int(obj1));
18816 if (SWIG_arg_fail(2)) SWIG_fail;
18817 }
18818 if (arg1) (arg1)->m_y = arg2;
18819
18820 Py_INCREF(Py_None); resultobj = Py_None;
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj;
18829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18830 int result;
18831 PyObject * obj0 = 0 ;
18832 char *kwnames[] = {
18833 (char *) "self", NULL
18834 };
18835
18836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18838 if (SWIG_arg_fail(1)) SWIG_fail;
18839 result = (int) ((arg1)->m_y);
18840
18841 {
18842 resultobj = SWIG_From_int((int)(result));
18843 }
18844 return resultobj;
18845 fail:
18846 return NULL;
18847 }
18848
18849
18850 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj;
18852 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18853 long arg2 ;
18854 PyObject * obj0 = 0 ;
18855 PyObject * obj1 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self",(char *) "m_keyCode", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 {
18864 arg2 = (long)(SWIG_As_long(obj1));
18865 if (SWIG_arg_fail(2)) SWIG_fail;
18866 }
18867 if (arg1) (arg1)->m_keyCode = arg2;
18868
18869 Py_INCREF(Py_None); resultobj = Py_None;
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18877 PyObject *resultobj;
18878 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18879 long result;
18880 PyObject * obj0 = 0 ;
18881 char *kwnames[] = {
18882 (char *) "self", NULL
18883 };
18884
18885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18887 if (SWIG_arg_fail(1)) SWIG_fail;
18888 result = (long) ((arg1)->m_keyCode);
18889
18890 {
18891 resultobj = SWIG_From_long((long)(result));
18892 }
18893 return resultobj;
18894 fail:
18895 return NULL;
18896 }
18897
18898
18899 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18900 PyObject *resultobj;
18901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18902 bool arg2 ;
18903 PyObject * obj0 = 0 ;
18904 PyObject * obj1 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "self",(char *) "m_controlDown", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18911 if (SWIG_arg_fail(1)) SWIG_fail;
18912 {
18913 arg2 = (bool)(SWIG_As_bool(obj1));
18914 if (SWIG_arg_fail(2)) SWIG_fail;
18915 }
18916 if (arg1) (arg1)->m_controlDown = arg2;
18917
18918 Py_INCREF(Py_None); resultobj = Py_None;
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj;
18927 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18928 bool result;
18929 PyObject * obj0 = 0 ;
18930 char *kwnames[] = {
18931 (char *) "self", NULL
18932 };
18933
18934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18936 if (SWIG_arg_fail(1)) SWIG_fail;
18937 result = (bool) ((arg1)->m_controlDown);
18938
18939 {
18940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18941 }
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18951 bool arg2 ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "self",(char *) "m_shiftDown", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 {
18962 arg2 = (bool)(SWIG_As_bool(obj1));
18963 if (SWIG_arg_fail(2)) SWIG_fail;
18964 }
18965 if (arg1) (arg1)->m_shiftDown = arg2;
18966
18967 Py_INCREF(Py_None); resultobj = Py_None;
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18975 PyObject *resultobj;
18976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18977 bool result;
18978 PyObject * obj0 = 0 ;
18979 char *kwnames[] = {
18980 (char *) "self", NULL
18981 };
18982
18983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18985 if (SWIG_arg_fail(1)) SWIG_fail;
18986 result = (bool) ((arg1)->m_shiftDown);
18987
18988 {
18989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18990 }
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj;
18999 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19000 bool arg2 ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 char *kwnames[] = {
19004 (char *) "self",(char *) "m_altDown", NULL
19005 };
19006
19007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19009 if (SWIG_arg_fail(1)) SWIG_fail;
19010 {
19011 arg2 = (bool)(SWIG_As_bool(obj1));
19012 if (SWIG_arg_fail(2)) SWIG_fail;
19013 }
19014 if (arg1) (arg1)->m_altDown = arg2;
19015
19016 Py_INCREF(Py_None); resultobj = Py_None;
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19024 PyObject *resultobj;
19025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19026 bool result;
19027 PyObject * obj0 = 0 ;
19028 char *kwnames[] = {
19029 (char *) "self", NULL
19030 };
19031
19032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19034 if (SWIG_arg_fail(1)) SWIG_fail;
19035 result = (bool) ((arg1)->m_altDown);
19036
19037 {
19038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19039 }
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj;
19048 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19049 bool arg2 ;
19050 PyObject * obj0 = 0 ;
19051 PyObject * obj1 = 0 ;
19052 char *kwnames[] = {
19053 (char *) "self",(char *) "m_metaDown", NULL
19054 };
19055
19056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19058 if (SWIG_arg_fail(1)) SWIG_fail;
19059 {
19060 arg2 = (bool)(SWIG_As_bool(obj1));
19061 if (SWIG_arg_fail(2)) SWIG_fail;
19062 }
19063 if (arg1) (arg1)->m_metaDown = arg2;
19064
19065 Py_INCREF(Py_None); resultobj = Py_None;
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19073 PyObject *resultobj;
19074 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19075 bool result;
19076 PyObject * obj0 = 0 ;
19077 char *kwnames[] = {
19078 (char *) "self", NULL
19079 };
19080
19081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19083 if (SWIG_arg_fail(1)) SWIG_fail;
19084 result = (bool) ((arg1)->m_metaDown);
19085
19086 {
19087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19088 }
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19096 PyObject *resultobj;
19097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19098 bool arg2 ;
19099 PyObject * obj0 = 0 ;
19100 PyObject * obj1 = 0 ;
19101 char *kwnames[] = {
19102 (char *) "self",(char *) "m_scanCode", NULL
19103 };
19104
19105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19107 if (SWIG_arg_fail(1)) SWIG_fail;
19108 {
19109 arg2 = (bool)(SWIG_As_bool(obj1));
19110 if (SWIG_arg_fail(2)) SWIG_fail;
19111 }
19112 if (arg1) (arg1)->m_scanCode = arg2;
19113
19114 Py_INCREF(Py_None); resultobj = Py_None;
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj;
19123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19124 bool result;
19125 PyObject * obj0 = 0 ;
19126 char *kwnames[] = {
19127 (char *) "self", NULL
19128 };
19129
19130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19132 if (SWIG_arg_fail(1)) SWIG_fail;
19133 result = (bool) ((arg1)->m_scanCode);
19134
19135 {
19136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19137 }
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19145 PyObject *resultobj;
19146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19147 unsigned int arg2 ;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char *kwnames[] = {
19151 (char *) "self",(char *) "m_rawCode", NULL
19152 };
19153
19154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19156 if (SWIG_arg_fail(1)) SWIG_fail;
19157 {
19158 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19159 if (SWIG_arg_fail(2)) SWIG_fail;
19160 }
19161 if (arg1) (arg1)->m_rawCode = arg2;
19162
19163 Py_INCREF(Py_None); resultobj = Py_None;
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj;
19172 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19173 unsigned int result;
19174 PyObject * obj0 = 0 ;
19175 char *kwnames[] = {
19176 (char *) "self", NULL
19177 };
19178
19179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19181 if (SWIG_arg_fail(1)) SWIG_fail;
19182 result = (unsigned int) ((arg1)->m_rawCode);
19183
19184 {
19185 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj;
19195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19196 unsigned int arg2 ;
19197 PyObject * obj0 = 0 ;
19198 PyObject * obj1 = 0 ;
19199 char *kwnames[] = {
19200 (char *) "self",(char *) "m_rawFlags", NULL
19201 };
19202
19203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19205 if (SWIG_arg_fail(1)) SWIG_fail;
19206 {
19207 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19208 if (SWIG_arg_fail(2)) SWIG_fail;
19209 }
19210 if (arg1) (arg1)->m_rawFlags = arg2;
19211
19212 Py_INCREF(Py_None); resultobj = Py_None;
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj;
19221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19222 unsigned int result;
19223 PyObject * obj0 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "self", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 result = (unsigned int) ((arg1)->m_rawFlags);
19232
19233 {
19234 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19235 }
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19243 PyObject *obj;
19244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19245 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19246 Py_INCREF(obj);
19247 return Py_BuildValue((char *)"");
19248 }
19249 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 wxSize const &arg1_defvalue = wxDefaultSize ;
19252 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19253 int arg2 = (int) 0 ;
19254 wxSizeEvent *result;
19255 wxSize temp1 ;
19256 PyObject * obj0 = 0 ;
19257 PyObject * obj1 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "sz",(char *) "winid", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19263 if (obj0) {
19264 {
19265 arg1 = &temp1;
19266 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19267 }
19268 }
19269 if (obj1) {
19270 {
19271 arg2 = (int)(SWIG_As_int(obj1));
19272 if (SWIG_arg_fail(2)) SWIG_fail;
19273 }
19274 }
19275 {
19276 PyThreadState* __tstate = wxPyBeginAllowThreads();
19277 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19278
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19290 PyObject *resultobj;
19291 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19292 wxSize result;
19293 PyObject * obj0 = 0 ;
19294 char *kwnames[] = {
19295 (char *) "self", NULL
19296 };
19297
19298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19300 if (SWIG_arg_fail(1)) SWIG_fail;
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 result = ((wxSizeEvent const *)arg1)->GetSize();
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 {
19309 wxSize * resultptr;
19310 resultptr = new wxSize((wxSize &)(result));
19311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19322 wxRect result;
19323 PyObject * obj0 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "self", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = ((wxSizeEvent const *)arg1)->GetRect();
19334
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 {
19339 wxRect * resultptr;
19340 resultptr = new wxRect((wxRect &)(result));
19341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19342 }
19343 return resultobj;
19344 fail:
19345 return NULL;
19346 }
19347
19348
19349 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19350 PyObject *resultobj;
19351 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19352 wxRect arg2 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "self",(char *) "rect", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19361 if (SWIG_arg_fail(1)) SWIG_fail;
19362 {
19363 wxRect * argp;
19364 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19365 if (SWIG_arg_fail(2)) SWIG_fail;
19366 if (argp == NULL) {
19367 SWIG_null_ref("wxRect");
19368 }
19369 if (SWIG_arg_fail(2)) SWIG_fail;
19370 arg2 = *argp;
19371 }
19372 {
19373 PyThreadState* __tstate = wxPyBeginAllowThreads();
19374 (arg1)->SetRect(arg2);
19375
19376 wxPyEndAllowThreads(__tstate);
19377 if (PyErr_Occurred()) SWIG_fail;
19378 }
19379 Py_INCREF(Py_None); resultobj = Py_None;
19380 return resultobj;
19381 fail:
19382 return NULL;
19383 }
19384
19385
19386 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19387 PyObject *resultobj;
19388 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19389 wxSize arg2 ;
19390 PyObject * obj0 = 0 ;
19391 PyObject * obj1 = 0 ;
19392 char *kwnames[] = {
19393 (char *) "self",(char *) "size", NULL
19394 };
19395
19396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19398 if (SWIG_arg_fail(1)) SWIG_fail;
19399 {
19400 wxSize * argp;
19401 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 if (argp == NULL) {
19404 SWIG_null_ref("wxSize");
19405 }
19406 if (SWIG_arg_fail(2)) SWIG_fail;
19407 arg2 = *argp;
19408 }
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 wxSizeEvent_SetSize(arg1,arg2);
19412
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 Py_INCREF(Py_None); resultobj = Py_None;
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19426 wxSize *arg2 = (wxSize *) 0 ;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char *kwnames[] = {
19430 (char *) "self",(char *) "m_size", NULL
19431 };
19432
19433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19435 if (SWIG_arg_fail(1)) SWIG_fail;
19436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(2)) SWIG_fail;
19438 if (arg1) (arg1)->m_size = *arg2;
19439
19440 Py_INCREF(Py_None); resultobj = Py_None;
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj;
19449 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19450 wxSize *result;
19451 PyObject * obj0 = 0 ;
19452 char *kwnames[] = {
19453 (char *) "self", NULL
19454 };
19455
19456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19458 if (SWIG_arg_fail(1)) SWIG_fail;
19459 result = (wxSize *)& ((arg1)->m_size);
19460
19461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19462 return resultobj;
19463 fail:
19464 return NULL;
19465 }
19466
19467
19468 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19469 PyObject *resultobj;
19470 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19471 wxRect *arg2 = (wxRect *) 0 ;
19472 PyObject * obj0 = 0 ;
19473 PyObject * obj1 = 0 ;
19474 char *kwnames[] = {
19475 (char *) "self",(char *) "m_rect", NULL
19476 };
19477
19478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19480 if (SWIG_arg_fail(1)) SWIG_fail;
19481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(2)) SWIG_fail;
19483 if (arg1) (arg1)->m_rect = *arg2;
19484
19485 Py_INCREF(Py_None); resultobj = Py_None;
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19495 wxRect *result;
19496 PyObject * obj0 = 0 ;
19497 char *kwnames[] = {
19498 (char *) "self", NULL
19499 };
19500
19501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19503 if (SWIG_arg_fail(1)) SWIG_fail;
19504 result = (wxRect *)& ((arg1)->m_rect);
19505
19506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19514 PyObject *obj;
19515 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19516 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19517 Py_INCREF(obj);
19518 return Py_BuildValue((char *)"");
19519 }
19520 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19521 PyObject *resultobj;
19522 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19523 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19524 int arg2 = (int) 0 ;
19525 wxMoveEvent *result;
19526 wxPoint temp1 ;
19527 PyObject * obj0 = 0 ;
19528 PyObject * obj1 = 0 ;
19529 char *kwnames[] = {
19530 (char *) "pos",(char *) "winid", NULL
19531 };
19532
19533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19534 if (obj0) {
19535 {
19536 arg1 = &temp1;
19537 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19538 }
19539 }
19540 if (obj1) {
19541 {
19542 arg2 = (int)(SWIG_As_int(obj1));
19543 if (SWIG_arg_fail(2)) SWIG_fail;
19544 }
19545 }
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19549
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19561 PyObject *resultobj;
19562 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19563 wxPoint result;
19564 PyObject * obj0 = 0 ;
19565 char *kwnames[] = {
19566 (char *) "self", NULL
19567 };
19568
19569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19571 if (SWIG_arg_fail(1)) SWIG_fail;
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = ((wxMoveEvent const *)arg1)->GetPosition();
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 {
19580 wxPoint * resultptr;
19581 resultptr = new wxPoint((wxPoint &)(result));
19582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19583 }
19584 return resultobj;
19585 fail:
19586 return NULL;
19587 }
19588
19589
19590 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19591 PyObject *resultobj;
19592 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19593 wxRect result;
19594 PyObject * obj0 = 0 ;
19595 char *kwnames[] = {
19596 (char *) "self", NULL
19597 };
19598
19599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19601 if (SWIG_arg_fail(1)) SWIG_fail;
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 result = ((wxMoveEvent const *)arg1)->GetRect();
19605
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 {
19610 wxRect * resultptr;
19611 resultptr = new wxRect((wxRect &)(result));
19612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19613 }
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19621 PyObject *resultobj;
19622 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19623 wxRect *arg2 = 0 ;
19624 wxRect temp2 ;
19625 PyObject * obj0 = 0 ;
19626 PyObject * obj1 = 0 ;
19627 char *kwnames[] = {
19628 (char *) "self",(char *) "rect", NULL
19629 };
19630
19631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19633 if (SWIG_arg_fail(1)) SWIG_fail;
19634 {
19635 arg2 = &temp2;
19636 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19637 }
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 (arg1)->SetRect((wxRect const &)*arg2);
19641
19642 wxPyEndAllowThreads(__tstate);
19643 if (PyErr_Occurred()) SWIG_fail;
19644 }
19645 Py_INCREF(Py_None); resultobj = Py_None;
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19653 PyObject *resultobj;
19654 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19655 wxPoint *arg2 = 0 ;
19656 wxPoint temp2 ;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 char *kwnames[] = {
19660 (char *) "self",(char *) "pos", NULL
19661 };
19662
19663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19665 if (SWIG_arg_fail(1)) SWIG_fail;
19666 {
19667 arg2 = &temp2;
19668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19669 }
19670 {
19671 PyThreadState* __tstate = wxPyBeginAllowThreads();
19672 (arg1)->SetPosition((wxPoint const &)*arg2);
19673
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 Py_INCREF(Py_None); resultobj = Py_None;
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19685 PyObject *obj;
19686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19687 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19688 Py_INCREF(obj);
19689 return Py_BuildValue((char *)"");
19690 }
19691 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj;
19693 int arg1 = (int) 0 ;
19694 wxPaintEvent *result;
19695 PyObject * obj0 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "Id", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19701 if (obj0) {
19702 {
19703 arg1 = (int)(SWIG_As_int(obj0));
19704 if (SWIG_arg_fail(1)) SWIG_fail;
19705 }
19706 }
19707 {
19708 PyThreadState* __tstate = wxPyBeginAllowThreads();
19709 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19710
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19722 PyObject *obj;
19723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19724 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19725 Py_INCREF(obj);
19726 return Py_BuildValue((char *)"");
19727 }
19728 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj;
19730 int arg1 = (int) 0 ;
19731 wxNcPaintEvent *result;
19732 PyObject * obj0 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "winid", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19738 if (obj0) {
19739 {
19740 arg1 = (int)(SWIG_As_int(obj0));
19741 if (SWIG_arg_fail(1)) SWIG_fail;
19742 }
19743 }
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19747
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19759 PyObject *obj;
19760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19761 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19762 Py_INCREF(obj);
19763 return Py_BuildValue((char *)"");
19764 }
19765 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj;
19767 int arg1 = (int) 0 ;
19768 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19769 wxEraseEvent *result;
19770 PyObject * obj0 = 0 ;
19771 PyObject * obj1 = 0 ;
19772 char *kwnames[] = {
19773 (char *) "Id",(char *) "dc", NULL
19774 };
19775
19776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19777 if (obj0) {
19778 {
19779 arg1 = (int)(SWIG_As_int(obj0));
19780 if (SWIG_arg_fail(1)) SWIG_fail;
19781 }
19782 }
19783 if (obj1) {
19784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19785 if (SWIG_arg_fail(2)) SWIG_fail;
19786 }
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj;
19803 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19804 wxDC *result;
19805 PyObject * obj0 = 0 ;
19806 char *kwnames[] = {
19807 (char *) "self", NULL
19808 };
19809
19810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19812 if (SWIG_arg_fail(1)) SWIG_fail;
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19816
19817 wxPyEndAllowThreads(__tstate);
19818 if (PyErr_Occurred()) SWIG_fail;
19819 }
19820 {
19821 resultobj = wxPyMake_wxObject(result, 0);
19822 }
19823 return resultobj;
19824 fail:
19825 return NULL;
19826 }
19827
19828
19829 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19830 PyObject *obj;
19831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19832 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19833 Py_INCREF(obj);
19834 return Py_BuildValue((char *)"");
19835 }
19836 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19839 int arg2 = (int) 0 ;
19840 wxFocusEvent *result;
19841 PyObject * obj0 = 0 ;
19842 PyObject * obj1 = 0 ;
19843 char *kwnames[] = {
19844 (char *) "type",(char *) "winid", NULL
19845 };
19846
19847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19848 if (obj0) {
19849 {
19850 arg1 = (wxEventType)(SWIG_As_int(obj0));
19851 if (SWIG_arg_fail(1)) SWIG_fail;
19852 }
19853 }
19854 if (obj1) {
19855 {
19856 arg2 = (int)(SWIG_As_int(obj1));
19857 if (SWIG_arg_fail(2)) SWIG_fail;
19858 }
19859 }
19860 {
19861 PyThreadState* __tstate = wxPyBeginAllowThreads();
19862 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19863
19864 wxPyEndAllowThreads(__tstate);
19865 if (PyErr_Occurred()) SWIG_fail;
19866 }
19867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19875 PyObject *resultobj;
19876 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19877 wxWindow *result;
19878 PyObject * obj0 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19889
19890 wxPyEndAllowThreads(__tstate);
19891 if (PyErr_Occurred()) SWIG_fail;
19892 }
19893 {
19894 resultobj = wxPyMake_wxObject(result, 0);
19895 }
19896 return resultobj;
19897 fail:
19898 return NULL;
19899 }
19900
19901
19902 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19903 PyObject *resultobj;
19904 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19905 wxWindow *arg2 = (wxWindow *) 0 ;
19906 PyObject * obj0 = 0 ;
19907 PyObject * obj1 = 0 ;
19908 char *kwnames[] = {
19909 (char *) "self",(char *) "win", NULL
19910 };
19911
19912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19914 if (SWIG_arg_fail(1)) SWIG_fail;
19915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19916 if (SWIG_arg_fail(2)) SWIG_fail;
19917 {
19918 PyThreadState* __tstate = wxPyBeginAllowThreads();
19919 (arg1)->SetWindow(arg2);
19920
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 Py_INCREF(Py_None); resultobj = Py_None;
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19932 PyObject *obj;
19933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19934 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19935 Py_INCREF(obj);
19936 return Py_BuildValue((char *)"");
19937 }
19938 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 wxWindow *arg1 = (wxWindow *) NULL ;
19941 wxChildFocusEvent *result;
19942 PyObject * obj0 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "win", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19948 if (obj0) {
19949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19950 if (SWIG_arg_fail(1)) SWIG_fail;
19951 }
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19955
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj;
19968 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19969 wxWindow *result;
19970 PyObject * obj0 = 0 ;
19971 char *kwnames[] = {
19972 (char *) "self", NULL
19973 };
19974
19975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19977 if (SWIG_arg_fail(1)) SWIG_fail;
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19981
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 {
19986 resultobj = wxPyMake_wxObject(result, 0);
19987 }
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19995 PyObject *obj;
19996 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19997 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19998 Py_INCREF(obj);
19999 return Py_BuildValue((char *)"");
20000 }
20001 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj;
20003 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20004 bool arg2 = (bool) true ;
20005 int arg3 = (int) 0 ;
20006 wxActivateEvent *result;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 PyObject * obj2 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "type",(char *) "active",(char *) "Id", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20015 if (obj0) {
20016 {
20017 arg1 = (wxEventType)(SWIG_As_int(obj0));
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 }
20020 }
20021 if (obj1) {
20022 {
20023 arg2 = (bool)(SWIG_As_bool(obj1));
20024 if (SWIG_arg_fail(2)) SWIG_fail;
20025 }
20026 }
20027 if (obj2) {
20028 {
20029 arg3 = (int)(SWIG_As_int(obj2));
20030 if (SWIG_arg_fail(3)) SWIG_fail;
20031 }
20032 }
20033 {
20034 PyThreadState* __tstate = wxPyBeginAllowThreads();
20035 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20036
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20041 return resultobj;
20042 fail:
20043 return NULL;
20044 }
20045
20046
20047 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20048 PyObject *resultobj;
20049 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20050 bool result;
20051 PyObject * obj0 = 0 ;
20052 char *kwnames[] = {
20053 (char *) "self", NULL
20054 };
20055
20056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20058 if (SWIG_arg_fail(1)) SWIG_fail;
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20062
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 {
20067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20068 }
20069 return resultobj;
20070 fail:
20071 return NULL;
20072 }
20073
20074
20075 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20076 PyObject *obj;
20077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20078 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20079 Py_INCREF(obj);
20080 return Py_BuildValue((char *)"");
20081 }
20082 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj;
20084 int arg1 = (int) 0 ;
20085 wxInitDialogEvent *result;
20086 PyObject * obj0 = 0 ;
20087 char *kwnames[] = {
20088 (char *) "Id", NULL
20089 };
20090
20091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20092 if (obj0) {
20093 {
20094 arg1 = (int)(SWIG_As_int(obj0));
20095 if (SWIG_arg_fail(1)) SWIG_fail;
20096 }
20097 }
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20113 PyObject *obj;
20114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20115 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20116 Py_INCREF(obj);
20117 return Py_BuildValue((char *)"");
20118 }
20119 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj;
20121 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20122 int arg2 = (int) 0 ;
20123 wxMenu *arg3 = (wxMenu *) NULL ;
20124 wxMenuEvent *result;
20125 PyObject * obj0 = 0 ;
20126 PyObject * obj1 = 0 ;
20127 PyObject * obj2 = 0 ;
20128 char *kwnames[] = {
20129 (char *) "type",(char *) "winid",(char *) "menu", NULL
20130 };
20131
20132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20133 if (obj0) {
20134 {
20135 arg1 = (wxEventType)(SWIG_As_int(obj0));
20136 if (SWIG_arg_fail(1)) SWIG_fail;
20137 }
20138 }
20139 if (obj1) {
20140 {
20141 arg2 = (int)(SWIG_As_int(obj1));
20142 if (SWIG_arg_fail(2)) SWIG_fail;
20143 }
20144 }
20145 if (obj2) {
20146 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20147 if (SWIG_arg_fail(3)) SWIG_fail;
20148 }
20149 {
20150 PyThreadState* __tstate = wxPyBeginAllowThreads();
20151 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20152
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj;
20165 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20166 int result;
20167 PyObject * obj0 = 0 ;
20168 char *kwnames[] = {
20169 (char *) "self", NULL
20170 };
20171
20172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20174 if (SWIG_arg_fail(1)) SWIG_fail;
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20178
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 {
20183 resultobj = SWIG_From_int((int)(result));
20184 }
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20194 bool result;
20195 PyObject * obj0 = 0 ;
20196 char *kwnames[] = {
20197 (char *) "self", NULL
20198 };
20199
20200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20202 if (SWIG_arg_fail(1)) SWIG_fail;
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20206
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20212 }
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj;
20221 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20222 wxMenu *result;
20223 PyObject * obj0 = 0 ;
20224 char *kwnames[] = {
20225 (char *) "self", NULL
20226 };
20227
20228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20234
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 {
20239 resultobj = wxPyMake_wxObject(result, 0);
20240 }
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20248 PyObject *obj;
20249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20250 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20251 Py_INCREF(obj);
20252 return Py_BuildValue((char *)"");
20253 }
20254 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20257 int arg2 = (int) 0 ;
20258 wxCloseEvent *result;
20259 PyObject * obj0 = 0 ;
20260 PyObject * obj1 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "type",(char *) "winid", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20266 if (obj0) {
20267 {
20268 arg1 = (wxEventType)(SWIG_As_int(obj0));
20269 if (SWIG_arg_fail(1)) SWIG_fail;
20270 }
20271 }
20272 if (obj1) {
20273 {
20274 arg2 = (int)(SWIG_As_int(obj1));
20275 if (SWIG_arg_fail(2)) SWIG_fail;
20276 }
20277 }
20278 {
20279 PyThreadState* __tstate = wxPyBeginAllowThreads();
20280 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20281
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20286 return resultobj;
20287 fail:
20288 return NULL;
20289 }
20290
20291
20292 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20293 PyObject *resultobj;
20294 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20295 bool arg2 ;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 char *kwnames[] = {
20299 (char *) "self",(char *) "logOff", NULL
20300 };
20301
20302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20304 if (SWIG_arg_fail(1)) SWIG_fail;
20305 {
20306 arg2 = (bool)(SWIG_As_bool(obj1));
20307 if (SWIG_arg_fail(2)) SWIG_fail;
20308 }
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 (arg1)->SetLoggingOff(arg2);
20312
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 Py_INCREF(Py_None); resultobj = Py_None;
20317 return resultobj;
20318 fail:
20319 return NULL;
20320 }
20321
20322
20323 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20324 PyObject *resultobj;
20325 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20326 bool result;
20327 PyObject * obj0 = 0 ;
20328 char *kwnames[] = {
20329 (char *) "self", NULL
20330 };
20331
20332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20334 if (SWIG_arg_fail(1)) SWIG_fail;
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20338
20339 wxPyEndAllowThreads(__tstate);
20340 if (PyErr_Occurred()) SWIG_fail;
20341 }
20342 {
20343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20344 }
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20352 PyObject *resultobj;
20353 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20354 bool arg2 = (bool) true ;
20355 PyObject * obj0 = 0 ;
20356 PyObject * obj1 = 0 ;
20357 char *kwnames[] = {
20358 (char *) "self",(char *) "veto", NULL
20359 };
20360
20361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 if (obj1) {
20365 {
20366 arg2 = (bool)(SWIG_As_bool(obj1));
20367 if (SWIG_arg_fail(2)) SWIG_fail;
20368 }
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 (arg1)->Veto(arg2);
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 Py_INCREF(Py_None); resultobj = Py_None;
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20387 bool arg2 ;
20388 PyObject * obj0 = 0 ;
20389 PyObject * obj1 = 0 ;
20390 char *kwnames[] = {
20391 (char *) "self",(char *) "canVeto", NULL
20392 };
20393
20394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20396 if (SWIG_arg_fail(1)) SWIG_fail;
20397 {
20398 arg2 = (bool)(SWIG_As_bool(obj1));
20399 if (SWIG_arg_fail(2)) SWIG_fail;
20400 }
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 (arg1)->SetCanVeto(arg2);
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 Py_INCREF(Py_None); resultobj = Py_None;
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20416 PyObject *resultobj;
20417 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20418 bool result;
20419 PyObject * obj0 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20430
20431 wxPyEndAllowThreads(__tstate);
20432 if (PyErr_Occurred()) SWIG_fail;
20433 }
20434 {
20435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20436 }
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj;
20445 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20446 bool result;
20447 PyObject * obj0 = 0 ;
20448 char *kwnames[] = {
20449 (char *) "self", NULL
20450 };
20451
20452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20454 if (SWIG_arg_fail(1)) SWIG_fail;
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20464 }
20465 return resultobj;
20466 fail:
20467 return NULL;
20468 }
20469
20470
20471 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20472 PyObject *obj;
20473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20474 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20475 Py_INCREF(obj);
20476 return Py_BuildValue((char *)"");
20477 }
20478 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20479 PyObject *resultobj;
20480 int arg1 = (int) 0 ;
20481 bool arg2 = (bool) false ;
20482 wxShowEvent *result;
20483 PyObject * obj0 = 0 ;
20484 PyObject * obj1 = 0 ;
20485 char *kwnames[] = {
20486 (char *) "winid",(char *) "show", NULL
20487 };
20488
20489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20490 if (obj0) {
20491 {
20492 arg1 = (int)(SWIG_As_int(obj0));
20493 if (SWIG_arg_fail(1)) SWIG_fail;
20494 }
20495 }
20496 if (obj1) {
20497 {
20498 arg2 = (bool)(SWIG_As_bool(obj1));
20499 if (SWIG_arg_fail(2)) SWIG_fail;
20500 }
20501 }
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20505
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20517 PyObject *resultobj;
20518 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20519 bool arg2 ;
20520 PyObject * obj0 = 0 ;
20521 PyObject * obj1 = 0 ;
20522 char *kwnames[] = {
20523 (char *) "self",(char *) "show", NULL
20524 };
20525
20526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20528 if (SWIG_arg_fail(1)) SWIG_fail;
20529 {
20530 arg2 = (bool)(SWIG_As_bool(obj1));
20531 if (SWIG_arg_fail(2)) SWIG_fail;
20532 }
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 (arg1)->SetShow(arg2);
20536
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 Py_INCREF(Py_None); resultobj = Py_None;
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20550 bool result;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "self", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 PyThreadState* __tstate = wxPyBeginAllowThreads();
20561 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20562
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20576 PyObject *obj;
20577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20578 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20579 Py_INCREF(obj);
20580 return Py_BuildValue((char *)"");
20581 }
20582 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20583 PyObject *resultobj;
20584 int arg1 = (int) 0 ;
20585 bool arg2 = (bool) true ;
20586 wxIconizeEvent *result;
20587 PyObject * obj0 = 0 ;
20588 PyObject * obj1 = 0 ;
20589 char *kwnames[] = {
20590 (char *) "id",(char *) "iconized", NULL
20591 };
20592
20593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20594 if (obj0) {
20595 {
20596 arg1 = (int)(SWIG_As_int(obj0));
20597 if (SWIG_arg_fail(1)) SWIG_fail;
20598 }
20599 }
20600 if (obj1) {
20601 {
20602 arg2 = (bool)(SWIG_As_bool(obj1));
20603 if (SWIG_arg_fail(2)) SWIG_fail;
20604 }
20605 }
20606 {
20607 PyThreadState* __tstate = wxPyBeginAllowThreads();
20608 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20609
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj;
20622 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20623 bool result;
20624 PyObject * obj0 = 0 ;
20625 char *kwnames[] = {
20626 (char *) "self", NULL
20627 };
20628
20629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20631 if (SWIG_arg_fail(1)) SWIG_fail;
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 result = (bool)(arg1)->Iconized();
20635
20636 wxPyEndAllowThreads(__tstate);
20637 if (PyErr_Occurred()) SWIG_fail;
20638 }
20639 {
20640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20641 }
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20649 PyObject *obj;
20650 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20651 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20652 Py_INCREF(obj);
20653 return Py_BuildValue((char *)"");
20654 }
20655 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj;
20657 int arg1 = (int) 0 ;
20658 wxMaximizeEvent *result;
20659 PyObject * obj0 = 0 ;
20660 char *kwnames[] = {
20661 (char *) "id", NULL
20662 };
20663
20664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20665 if (obj0) {
20666 {
20667 arg1 = (int)(SWIG_As_int(obj0));
20668 if (SWIG_arg_fail(1)) SWIG_fail;
20669 }
20670 }
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20674
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20686 PyObject *obj;
20687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20688 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20689 Py_INCREF(obj);
20690 return Py_BuildValue((char *)"");
20691 }
20692 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20693 PyObject *resultobj;
20694 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20695 wxPoint result;
20696 PyObject * obj0 = 0 ;
20697 char *kwnames[] = {
20698 (char *) "self", NULL
20699 };
20700
20701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(1)) SWIG_fail;
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (arg1)->GetPosition();
20707
20708 wxPyEndAllowThreads(__tstate);
20709 if (PyErr_Occurred()) SWIG_fail;
20710 }
20711 {
20712 wxPoint * resultptr;
20713 resultptr = new wxPoint((wxPoint &)(result));
20714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20715 }
20716 return resultobj;
20717 fail:
20718 return NULL;
20719 }
20720
20721
20722 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20723 PyObject *resultobj;
20724 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20725 int result;
20726 PyObject * obj0 = 0 ;
20727 char *kwnames[] = {
20728 (char *) "self", NULL
20729 };
20730
20731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20733 if (SWIG_arg_fail(1)) SWIG_fail;
20734 {
20735 PyThreadState* __tstate = wxPyBeginAllowThreads();
20736 result = (int)(arg1)->GetNumberOfFiles();
20737
20738 wxPyEndAllowThreads(__tstate);
20739 if (PyErr_Occurred()) SWIG_fail;
20740 }
20741 {
20742 resultobj = SWIG_From_int((int)(result));
20743 }
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj;
20752 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20753 PyObject *result;
20754 PyObject * obj0 = 0 ;
20755 char *kwnames[] = {
20756 (char *) "self", NULL
20757 };
20758
20759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 {
20763 PyThreadState* __tstate = wxPyBeginAllowThreads();
20764 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20765
20766 wxPyEndAllowThreads(__tstate);
20767 if (PyErr_Occurred()) SWIG_fail;
20768 }
20769 resultobj = result;
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20777 PyObject *obj;
20778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20779 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20780 Py_INCREF(obj);
20781 return Py_BuildValue((char *)"");
20782 }
20783 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj;
20785 int arg1 = (int) 0 ;
20786 wxUpdateUIEvent *result;
20787 PyObject * obj0 = 0 ;
20788 char *kwnames[] = {
20789 (char *) "commandId", NULL
20790 };
20791
20792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20793 if (obj0) {
20794 {
20795 arg1 = (int)(SWIG_As_int(obj0));
20796 if (SWIG_arg_fail(1)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20814 PyObject *resultobj;
20815 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20816 bool result;
20817 PyObject * obj0 = 0 ;
20818 char *kwnames[] = {
20819 (char *) "self", NULL
20820 };
20821
20822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20824 if (SWIG_arg_fail(1)) SWIG_fail;
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20828
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 {
20833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20834 }
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20842 PyObject *resultobj;
20843 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20844 bool result;
20845 PyObject * obj0 = 0 ;
20846 char *kwnames[] = {
20847 (char *) "self", NULL
20848 };
20849
20850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20852 if (SWIG_arg_fail(1)) SWIG_fail;
20853 {
20854 PyThreadState* __tstate = wxPyBeginAllowThreads();
20855 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20856
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj;
20871 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20872 wxString result;
20873 PyObject * obj0 = 0 ;
20874 char *kwnames[] = {
20875 (char *) "self", NULL
20876 };
20877
20878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20880 if (SWIG_arg_fail(1)) SWIG_fail;
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20884
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 #if wxUSE_UNICODE
20890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20891 #else
20892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20893 #endif
20894 }
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20902 PyObject *resultobj;
20903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20904 bool result;
20905 PyObject * obj0 = 0 ;
20906 char *kwnames[] = {
20907 (char *) "self", NULL
20908 };
20909
20910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20912 if (SWIG_arg_fail(1)) SWIG_fail;
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20916
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 {
20921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20922 }
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20932 bool result;
20933 PyObject * obj0 = 0 ;
20934 char *kwnames[] = {
20935 (char *) "self", NULL
20936 };
20937
20938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20940 if (SWIG_arg_fail(1)) SWIG_fail;
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20944
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 {
20949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20950 }
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20960 bool result;
20961 PyObject * obj0 = 0 ;
20962 char *kwnames[] = {
20963 (char *) "self", NULL
20964 };
20965
20966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20968 if (SWIG_arg_fail(1)) SWIG_fail;
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20972
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 {
20977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20986 PyObject *resultobj;
20987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20988 bool arg2 ;
20989 PyObject * obj0 = 0 ;
20990 PyObject * obj1 = 0 ;
20991 char *kwnames[] = {
20992 (char *) "self",(char *) "check", NULL
20993 };
20994
20995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20997 if (SWIG_arg_fail(1)) SWIG_fail;
20998 {
20999 arg2 = (bool)(SWIG_As_bool(obj1));
21000 if (SWIG_arg_fail(2)) SWIG_fail;
21001 }
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 (arg1)->Check(arg2);
21005
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 Py_INCREF(Py_None); resultobj = Py_None;
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj;
21018 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21019 bool arg2 ;
21020 PyObject * obj0 = 0 ;
21021 PyObject * obj1 = 0 ;
21022 char *kwnames[] = {
21023 (char *) "self",(char *) "enable", NULL
21024 };
21025
21026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 {
21030 arg2 = (bool)(SWIG_As_bool(obj1));
21031 if (SWIG_arg_fail(2)) SWIG_fail;
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 (arg1)->Enable(arg2);
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 Py_INCREF(Py_None); resultobj = Py_None;
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj;
21049 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21050 wxString *arg2 = 0 ;
21051 bool temp2 = false ;
21052 PyObject * obj0 = 0 ;
21053 PyObject * obj1 = 0 ;
21054 char *kwnames[] = {
21055 (char *) "self",(char *) "text", NULL
21056 };
21057
21058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21060 if (SWIG_arg_fail(1)) SWIG_fail;
21061 {
21062 arg2 = wxString_in_helper(obj1);
21063 if (arg2 == NULL) SWIG_fail;
21064 temp2 = true;
21065 }
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 (arg1)->SetText((wxString const &)*arg2);
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 Py_INCREF(Py_None); resultobj = Py_None;
21074 {
21075 if (temp2)
21076 delete arg2;
21077 }
21078 return resultobj;
21079 fail:
21080 {
21081 if (temp2)
21082 delete arg2;
21083 }
21084 return NULL;
21085 }
21086
21087
21088 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21089 PyObject *resultobj;
21090 long arg1 ;
21091 PyObject * obj0 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "updateInterval", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21097 {
21098 arg1 = (long)(SWIG_As_long(obj0));
21099 if (SWIG_arg_fail(1)) SWIG_fail;
21100 }
21101 {
21102 PyThreadState* __tstate = wxPyBeginAllowThreads();
21103 wxUpdateUIEvent::SetUpdateInterval(arg1);
21104
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 Py_INCREF(Py_None); resultobj = Py_None;
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21116 PyObject *resultobj;
21117 long result;
21118 char *kwnames[] = {
21119 NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21126
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 {
21131 resultobj = SWIG_From_long((long)(result));
21132 }
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21140 PyObject *resultobj;
21141 wxWindow *arg1 = (wxWindow *) 0 ;
21142 bool result;
21143 PyObject * obj0 = 0 ;
21144 char *kwnames[] = {
21145 (char *) "win", NULL
21146 };
21147
21148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21150 if (SWIG_arg_fail(1)) SWIG_fail;
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21154
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 {
21159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21160 }
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj;
21169 char *kwnames[] = {
21170 NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 wxUpdateUIEvent::ResetUpdateTime();
21177
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 Py_INCREF(Py_None); resultobj = Py_None;
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxUpdateUIMode arg1 ;
21191 PyObject * obj0 = 0 ;
21192 char *kwnames[] = {
21193 (char *) "mode", NULL
21194 };
21195
21196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21197 {
21198 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21199 if (SWIG_arg_fail(1)) SWIG_fail;
21200 }
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 Py_INCREF(Py_None); resultobj = Py_None;
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21216 PyObject *resultobj;
21217 wxUpdateUIMode result;
21218 char *kwnames[] = {
21219 NULL
21220 };
21221
21222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21226
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 resultobj = SWIG_From_int((result));
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21238 PyObject *obj;
21239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21240 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21241 Py_INCREF(obj);
21242 return Py_BuildValue((char *)"");
21243 }
21244 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj;
21246 wxSysColourChangedEvent *result;
21247 char *kwnames[] = {
21248 NULL
21249 };
21250
21251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21260 return resultobj;
21261 fail:
21262 return NULL;
21263 }
21264
21265
21266 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21267 PyObject *obj;
21268 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21269 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21270 Py_INCREF(obj);
21271 return Py_BuildValue((char *)"");
21272 }
21273 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21274 PyObject *resultobj;
21275 int arg1 = (int) 0 ;
21276 wxWindow *arg2 = (wxWindow *) NULL ;
21277 wxMouseCaptureChangedEvent *result;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char *kwnames[] = {
21281 (char *) "winid",(char *) "gainedCapture", NULL
21282 };
21283
21284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21285 if (obj0) {
21286 {
21287 arg1 = (int)(SWIG_As_int(obj0));
21288 if (SWIG_arg_fail(1)) SWIG_fail;
21289 }
21290 }
21291 if (obj1) {
21292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(2)) SWIG_fail;
21294 }
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21298
21299 wxPyEndAllowThreads(__tstate);
21300 if (PyErr_Occurred()) SWIG_fail;
21301 }
21302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21312 wxWindow *result;
21313 PyObject * obj0 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 {
21329 resultobj = wxPyMake_wxObject(result, 0);
21330 }
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21338 PyObject *obj;
21339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21340 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21341 Py_INCREF(obj);
21342 return Py_BuildValue((char *)"");
21343 }
21344 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21345 PyObject *resultobj;
21346 wxDisplayChangedEvent *result;
21347 char *kwnames[] = {
21348 NULL
21349 };
21350
21351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21352 {
21353 PyThreadState* __tstate = wxPyBeginAllowThreads();
21354 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21355
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21367 PyObject *obj;
21368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21369 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21370 Py_INCREF(obj);
21371 return Py_BuildValue((char *)"");
21372 }
21373 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21374 PyObject *resultobj;
21375 int arg1 = (int) 0 ;
21376 wxPaletteChangedEvent *result;
21377 PyObject * obj0 = 0 ;
21378 char *kwnames[] = {
21379 (char *) "id", NULL
21380 };
21381
21382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21383 if (obj0) {
21384 {
21385 arg1 = (int)(SWIG_As_int(obj0));
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 }
21388 }
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21392
21393 wxPyEndAllowThreads(__tstate);
21394 if (PyErr_Occurred()) SWIG_fail;
21395 }
21396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj;
21405 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21406 wxWindow *arg2 = (wxWindow *) 0 ;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "win", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21417 if (SWIG_arg_fail(2)) SWIG_fail;
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 (arg1)->SetChangedWindow(arg2);
21421
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 Py_INCREF(Py_None); resultobj = Py_None;
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj;
21434 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21435 wxWindow *result;
21436 PyObject * obj0 = 0 ;
21437 char *kwnames[] = {
21438 (char *) "self", NULL
21439 };
21440
21441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21443 if (SWIG_arg_fail(1)) SWIG_fail;
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 result = (wxWindow *)(arg1)->GetChangedWindow();
21447
21448 wxPyEndAllowThreads(__tstate);
21449 if (PyErr_Occurred()) SWIG_fail;
21450 }
21451 {
21452 resultobj = wxPyMake_wxObject(result, 0);
21453 }
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21461 PyObject *obj;
21462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21463 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21464 Py_INCREF(obj);
21465 return Py_BuildValue((char *)"");
21466 }
21467 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21468 PyObject *resultobj;
21469 int arg1 = (int) 0 ;
21470 wxQueryNewPaletteEvent *result;
21471 PyObject * obj0 = 0 ;
21472 char *kwnames[] = {
21473 (char *) "winid", NULL
21474 };
21475
21476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21477 if (obj0) {
21478 {
21479 arg1 = (int)(SWIG_As_int(obj0));
21480 if (SWIG_arg_fail(1)) SWIG_fail;
21481 }
21482 }
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21486
21487 wxPyEndAllowThreads(__tstate);
21488 if (PyErr_Occurred()) SWIG_fail;
21489 }
21490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj;
21499 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21500 bool arg2 ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self",(char *) "realized", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 {
21511 arg2 = (bool)(SWIG_As_bool(obj1));
21512 if (SWIG_arg_fail(2)) SWIG_fail;
21513 }
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 (arg1)->SetPaletteRealized(arg2);
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 Py_INCREF(Py_None); resultobj = Py_None;
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj;
21530 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21531 bool result;
21532 PyObject * obj0 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "self", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21539 if (SWIG_arg_fail(1)) SWIG_fail;
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21543
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 {
21548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21549 }
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21557 PyObject *obj;
21558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21559 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21560 Py_INCREF(obj);
21561 return Py_BuildValue((char *)"");
21562 }
21563 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21564 PyObject *resultobj;
21565 wxNavigationKeyEvent *result;
21566 char *kwnames[] = {
21567 NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21571 {
21572 PyThreadState* __tstate = wxPyBeginAllowThreads();
21573 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21574
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj;
21587 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21588 bool result;
21589 PyObject * obj0 = 0 ;
21590 char *kwnames[] = {
21591 (char *) "self", NULL
21592 };
21593
21594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21596 if (SWIG_arg_fail(1)) SWIG_fail;
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 {
21605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21606 }
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj;
21615 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21616 bool arg2 ;
21617 PyObject * obj0 = 0 ;
21618 PyObject * obj1 = 0 ;
21619 char *kwnames[] = {
21620 (char *) "self",(char *) "forward", NULL
21621 };
21622
21623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21625 if (SWIG_arg_fail(1)) SWIG_fail;
21626 {
21627 arg2 = (bool)(SWIG_As_bool(obj1));
21628 if (SWIG_arg_fail(2)) SWIG_fail;
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 (arg1)->SetDirection(arg2);
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 Py_INCREF(Py_None); resultobj = Py_None;
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj;
21646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21647 bool result;
21648 PyObject * obj0 = 0 ;
21649 char *kwnames[] = {
21650 (char *) "self", NULL
21651 };
21652
21653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21655 if (SWIG_arg_fail(1)) SWIG_fail;
21656 {
21657 PyThreadState* __tstate = wxPyBeginAllowThreads();
21658 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21659
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 {
21664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21665 }
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21673 PyObject *resultobj;
21674 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21675 bool arg2 ;
21676 PyObject * obj0 = 0 ;
21677 PyObject * obj1 = 0 ;
21678 char *kwnames[] = {
21679 (char *) "self",(char *) "ischange", NULL
21680 };
21681
21682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21684 if (SWIG_arg_fail(1)) SWIG_fail;
21685 {
21686 arg2 = (bool)(SWIG_As_bool(obj1));
21687 if (SWIG_arg_fail(2)) SWIG_fail;
21688 }
21689 {
21690 PyThreadState* __tstate = wxPyBeginAllowThreads();
21691 (arg1)->SetWindowChange(arg2);
21692
21693 wxPyEndAllowThreads(__tstate);
21694 if (PyErr_Occurred()) SWIG_fail;
21695 }
21696 Py_INCREF(Py_None); resultobj = Py_None;
21697 return resultobj;
21698 fail:
21699 return NULL;
21700 }
21701
21702
21703 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21704 PyObject *resultobj;
21705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21706 bool result;
21707 PyObject * obj0 = 0 ;
21708 char *kwnames[] = {
21709 (char *) "self", NULL
21710 };
21711
21712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(1)) SWIG_fail;
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21718
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 {
21723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21724 }
21725 return resultobj;
21726 fail:
21727 return NULL;
21728 }
21729
21730
21731 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21732 PyObject *resultobj;
21733 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21734 bool arg2 ;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 char *kwnames[] = {
21738 (char *) "self",(char *) "bIs", NULL
21739 };
21740
21741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21743 if (SWIG_arg_fail(1)) SWIG_fail;
21744 {
21745 arg2 = (bool)(SWIG_As_bool(obj1));
21746 if (SWIG_arg_fail(2)) SWIG_fail;
21747 }
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 (arg1)->SetFromTab(arg2);
21751
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 Py_INCREF(Py_None); resultobj = Py_None;
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21763 PyObject *resultobj;
21764 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21765 long arg2 ;
21766 PyObject * obj0 = 0 ;
21767 PyObject * obj1 = 0 ;
21768 char *kwnames[] = {
21769 (char *) "self",(char *) "flags", NULL
21770 };
21771
21772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21774 if (SWIG_arg_fail(1)) SWIG_fail;
21775 {
21776 arg2 = (long)(SWIG_As_long(obj1));
21777 if (SWIG_arg_fail(2)) SWIG_fail;
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 (arg1)->SetFlags(arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 Py_INCREF(Py_None); resultobj = Py_None;
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21796 wxWindow *result;
21797 PyObject * obj0 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "self", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21808
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = wxPyMake_wxObject(result, 0);
21814 }
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21822 PyObject *resultobj;
21823 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21824 wxWindow *arg2 = (wxWindow *) 0 ;
21825 PyObject * obj0 = 0 ;
21826 PyObject * obj1 = 0 ;
21827 char *kwnames[] = {
21828 (char *) "self",(char *) "win", NULL
21829 };
21830
21831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21833 if (SWIG_arg_fail(1)) SWIG_fail;
21834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21835 if (SWIG_arg_fail(2)) SWIG_fail;
21836 {
21837 PyThreadState* __tstate = wxPyBeginAllowThreads();
21838 (arg1)->SetCurrentFocus(arg2);
21839
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 Py_INCREF(Py_None); resultobj = Py_None;
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21851 PyObject *obj;
21852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21853 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21854 Py_INCREF(obj);
21855 return Py_BuildValue((char *)"");
21856 }
21857 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21858 PyObject *resultobj;
21859 wxWindow *arg1 = (wxWindow *) NULL ;
21860 wxWindowCreateEvent *result;
21861 PyObject * obj0 = 0 ;
21862 char *kwnames[] = {
21863 (char *) "win", NULL
21864 };
21865
21866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21867 if (obj0) {
21868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21869 if (SWIG_arg_fail(1)) SWIG_fail;
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21888 wxWindow *result;
21889 PyObject * obj0 = 0 ;
21890 char *kwnames[] = {
21891 (char *) "self", NULL
21892 };
21893
21894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(1)) SWIG_fail;
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21900
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 {
21905 resultobj = wxPyMake_wxObject(result, 0);
21906 }
21907 return resultobj;
21908 fail:
21909 return NULL;
21910 }
21911
21912
21913 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21914 PyObject *obj;
21915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21916 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21917 Py_INCREF(obj);
21918 return Py_BuildValue((char *)"");
21919 }
21920 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21921 PyObject *resultobj;
21922 wxWindow *arg1 = (wxWindow *) NULL ;
21923 wxWindowDestroyEvent *result;
21924 PyObject * obj0 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "win", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21930 if (obj0) {
21931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21932 if (SWIG_arg_fail(1)) SWIG_fail;
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj;
21950 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21951 wxWindow *result;
21952 PyObject * obj0 = 0 ;
21953 char *kwnames[] = {
21954 (char *) "self", NULL
21955 };
21956
21957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21959 if (SWIG_arg_fail(1)) SWIG_fail;
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21963
21964 wxPyEndAllowThreads(__tstate);
21965 if (PyErr_Occurred()) SWIG_fail;
21966 }
21967 {
21968 resultobj = wxPyMake_wxObject(result, 0);
21969 }
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21977 PyObject *obj;
21978 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21979 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21980 Py_INCREF(obj);
21981 return Py_BuildValue((char *)"");
21982 }
21983 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21984 PyObject *resultobj;
21985 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21986 int arg2 = (int) 0 ;
21987 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21988 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21989 wxContextMenuEvent *result;
21990 wxPoint temp3 ;
21991 PyObject * obj0 = 0 ;
21992 PyObject * obj1 = 0 ;
21993 PyObject * obj2 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "type",(char *) "winid",(char *) "pt", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21999 if (obj0) {
22000 {
22001 arg1 = (wxEventType)(SWIG_As_int(obj0));
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 }
22004 }
22005 if (obj1) {
22006 {
22007 arg2 = (int)(SWIG_As_int(obj1));
22008 if (SWIG_arg_fail(2)) SWIG_fail;
22009 }
22010 }
22011 if (obj2) {
22012 {
22013 arg3 = &temp3;
22014 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22015 }
22016 }
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22020
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22032 PyObject *resultobj;
22033 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22034 wxPoint *result;
22035 PyObject * obj0 = 0 ;
22036 char *kwnames[] = {
22037 (char *) "self", NULL
22038 };
22039
22040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(1)) SWIG_fail;
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 {
22046 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22047 result = (wxPoint *) &_result_ref;
22048 }
22049
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22054 return resultobj;
22055 fail:
22056 return NULL;
22057 }
22058
22059
22060 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22061 PyObject *resultobj;
22062 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22063 wxPoint *arg2 = 0 ;
22064 wxPoint temp2 ;
22065 PyObject * obj0 = 0 ;
22066 PyObject * obj1 = 0 ;
22067 char *kwnames[] = {
22068 (char *) "self",(char *) "pos", NULL
22069 };
22070
22071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22073 if (SWIG_arg_fail(1)) SWIG_fail;
22074 {
22075 arg2 = &temp2;
22076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22077 }
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 (arg1)->SetPosition((wxPoint const &)*arg2);
22081
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 Py_INCREF(Py_None); resultobj = Py_None;
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22093 PyObject *obj;
22094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22095 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22096 Py_INCREF(obj);
22097 return Py_BuildValue((char *)"");
22098 }
22099 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj;
22101 wxIdleEvent *result;
22102 char *kwnames[] = {
22103 NULL
22104 };
22105
22106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (wxIdleEvent *)new wxIdleEvent();
22110
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22122 PyObject *resultobj;
22123 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22124 bool arg2 = (bool) true ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 char *kwnames[] = {
22128 (char *) "self",(char *) "needMore", NULL
22129 };
22130
22131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(1)) SWIG_fail;
22134 if (obj1) {
22135 {
22136 arg2 = (bool)(SWIG_As_bool(obj1));
22137 if (SWIG_arg_fail(2)) SWIG_fail;
22138 }
22139 }
22140 {
22141 PyThreadState* __tstate = wxPyBeginAllowThreads();
22142 (arg1)->RequestMore(arg2);
22143
22144 wxPyEndAllowThreads(__tstate);
22145 if (PyErr_Occurred()) SWIG_fail;
22146 }
22147 Py_INCREF(Py_None); resultobj = Py_None;
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22155 PyObject *resultobj;
22156 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22157 bool result;
22158 PyObject * obj0 = 0 ;
22159 char *kwnames[] = {
22160 (char *) "self", NULL
22161 };
22162
22163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22165 if (SWIG_arg_fail(1)) SWIG_fail;
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22169
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 {
22174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22175 }
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22183 PyObject *resultobj;
22184 wxIdleMode arg1 ;
22185 PyObject * obj0 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "mode", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22191 {
22192 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22193 if (SWIG_arg_fail(1)) SWIG_fail;
22194 }
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 wxIdleEvent::SetMode((wxIdleMode )arg1);
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_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22210 PyObject *resultobj;
22211 wxIdleMode result;
22212 char *kwnames[] = {
22213 NULL
22214 };
22215
22216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (wxIdleMode)wxIdleEvent::GetMode();
22220
22221 wxPyEndAllowThreads(__tstate);
22222 if (PyErr_Occurred()) SWIG_fail;
22223 }
22224 resultobj = SWIG_From_int((result));
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxWindow *arg1 = (wxWindow *) 0 ;
22234 bool result;
22235 PyObject * obj0 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "win", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(1)) SWIG_fail;
22243 {
22244 PyThreadState* __tstate = wxPyBeginAllowThreads();
22245 result = (bool)wxIdleEvent::CanSend(arg1);
22246
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 {
22251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22252 }
22253 return resultobj;
22254 fail:
22255 return NULL;
22256 }
22257
22258
22259 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22260 PyObject *obj;
22261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22262 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22263 Py_INCREF(obj);
22264 return Py_BuildValue((char *)"");
22265 }
22266 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22267 PyObject *resultobj;
22268 int arg1 = (int) 0 ;
22269 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22270 wxPyEvent *result;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char *kwnames[] = {
22274 (char *) "winid",(char *) "commandType", NULL
22275 };
22276
22277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22278 if (obj0) {
22279 {
22280 arg1 = (int)(SWIG_As_int(obj0));
22281 if (SWIG_arg_fail(1)) SWIG_fail;
22282 }
22283 }
22284 if (obj1) {
22285 {
22286 arg2 = (wxEventType)(SWIG_As_int(obj1));
22287 if (SWIG_arg_fail(2)) SWIG_fail;
22288 }
22289 }
22290 {
22291 PyThreadState* __tstate = wxPyBeginAllowThreads();
22292 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22293
22294 wxPyEndAllowThreads(__tstate);
22295 if (PyErr_Occurred()) SWIG_fail;
22296 }
22297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22307 PyObject * obj0 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 PyThreadState* __tstate = wxPyBeginAllowThreads();
22317 delete arg1;
22318
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 Py_INCREF(Py_None); resultobj = Py_None;
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22330 PyObject *resultobj;
22331 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22332 PyObject *arg2 = (PyObject *) 0 ;
22333 PyObject * obj0 = 0 ;
22334 PyObject * obj1 = 0 ;
22335 char *kwnames[] = {
22336 (char *) "self",(char *) "self", NULL
22337 };
22338
22339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22341 if (SWIG_arg_fail(1)) SWIG_fail;
22342 arg2 = obj1;
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 (arg1)->SetSelf(arg2);
22346
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 Py_INCREF(Py_None); resultobj = Py_None;
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22358 PyObject *resultobj;
22359 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22360 PyObject *result;
22361 PyObject * obj0 = 0 ;
22362 char *kwnames[] = {
22363 (char *) "self", NULL
22364 };
22365
22366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22368 if (SWIG_arg_fail(1)) SWIG_fail;
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 result = (PyObject *)(arg1)->GetSelf();
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 resultobj = result;
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22384 PyObject *obj;
22385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22386 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22387 Py_INCREF(obj);
22388 return Py_BuildValue((char *)"");
22389 }
22390 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj;
22392 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22393 int arg2 = (int) 0 ;
22394 wxPyCommandEvent *result;
22395 PyObject * obj0 = 0 ;
22396 PyObject * obj1 = 0 ;
22397 char *kwnames[] = {
22398 (char *) "commandType",(char *) "id", NULL
22399 };
22400
22401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22402 if (obj0) {
22403 {
22404 arg1 = (wxEventType)(SWIG_As_int(obj0));
22405 if (SWIG_arg_fail(1)) SWIG_fail;
22406 }
22407 }
22408 if (obj1) {
22409 {
22410 arg2 = (int)(SWIG_As_int(obj1));
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 }
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22417
22418 wxPyEndAllowThreads(__tstate);
22419 if (PyErr_Occurred()) SWIG_fail;
22420 }
22421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22422 return resultobj;
22423 fail:
22424 return NULL;
22425 }
22426
22427
22428 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22429 PyObject *resultobj;
22430 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22431 PyObject * obj0 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 delete arg1;
22442
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 Py_INCREF(Py_None); resultobj = Py_None;
22447 return resultobj;
22448 fail:
22449 return NULL;
22450 }
22451
22452
22453 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22454 PyObject *resultobj;
22455 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22456 PyObject *arg2 = (PyObject *) 0 ;
22457 PyObject * obj0 = 0 ;
22458 PyObject * obj1 = 0 ;
22459 char *kwnames[] = {
22460 (char *) "self",(char *) "self", NULL
22461 };
22462
22463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22465 if (SWIG_arg_fail(1)) SWIG_fail;
22466 arg2 = obj1;
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 (arg1)->SetSelf(arg2);
22470
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 Py_INCREF(Py_None); resultobj = Py_None;
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22482 PyObject *resultobj;
22483 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22484 PyObject *result;
22485 PyObject * obj0 = 0 ;
22486 char *kwnames[] = {
22487 (char *) "self", NULL
22488 };
22489
22490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22492 if (SWIG_arg_fail(1)) SWIG_fail;
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = (PyObject *)(arg1)->GetSelf();
22496
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = result;
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22508 PyObject *obj;
22509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22510 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22511 Py_INCREF(obj);
22512 return Py_BuildValue((char *)"");
22513 }
22514 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj;
22516 wxWindow *arg1 = (wxWindow *) 0 ;
22517 wxDateTime *arg2 = 0 ;
22518 wxEventType arg3 ;
22519 wxDateEvent *result;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522 PyObject * obj2 = 0 ;
22523 char *kwnames[] = {
22524 (char *) "win",(char *) "dt",(char *) "type", NULL
22525 };
22526
22527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(1)) SWIG_fail;
22530 {
22531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 if (arg2 == NULL) {
22534 SWIG_null_ref("wxDateTime");
22535 }
22536 if (SWIG_arg_fail(2)) SWIG_fail;
22537 }
22538 {
22539 arg3 = (wxEventType)(SWIG_As_int(obj2));
22540 if (SWIG_arg_fail(3)) SWIG_fail;
22541 }
22542 {
22543 PyThreadState* __tstate = wxPyBeginAllowThreads();
22544 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22545
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj;
22558 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22559 wxDateTime *result;
22560 PyObject * obj0 = 0 ;
22561 char *kwnames[] = {
22562 (char *) "self", NULL
22563 };
22564
22565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22567 if (SWIG_arg_fail(1)) SWIG_fail;
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 {
22571 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22572 result = (wxDateTime *) &_result_ref;
22573 }
22574
22575 wxPyEndAllowThreads(__tstate);
22576 if (PyErr_Occurred()) SWIG_fail;
22577 }
22578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22586 PyObject *resultobj;
22587 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22588 wxDateTime *arg2 = 0 ;
22589 PyObject * obj0 = 0 ;
22590 PyObject * obj1 = 0 ;
22591 char *kwnames[] = {
22592 (char *) "self",(char *) "date", NULL
22593 };
22594
22595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22597 if (SWIG_arg_fail(1)) SWIG_fail;
22598 {
22599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 if (arg2 == NULL) {
22602 SWIG_null_ref("wxDateTime");
22603 }
22604 if (SWIG_arg_fail(2)) SWIG_fail;
22605 }
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 (arg1)->SetDate((wxDateTime const &)*arg2);
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 * DateEvent_swigregister(PyObject *, PyObject *args) {
22621 PyObject *obj;
22622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22623 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22624 Py_INCREF(obj);
22625 return Py_BuildValue((char *)"");
22626 }
22627 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22628 PyObject *resultobj;
22629 wxPyApp *result;
22630 char *kwnames[] = {
22631 NULL
22632 };
22633
22634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (wxPyApp *)new_wxPyApp();
22638
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj;
22651 wxPyApp *arg1 = (wxPyApp *) 0 ;
22652 PyObject * obj0 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 PyThreadState* __tstate = wxPyBeginAllowThreads();
22662 delete arg1;
22663
22664 wxPyEndAllowThreads(__tstate);
22665 if (PyErr_Occurred()) SWIG_fail;
22666 }
22667 Py_INCREF(Py_None); resultobj = Py_None;
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22675 PyObject *resultobj;
22676 wxPyApp *arg1 = (wxPyApp *) 0 ;
22677 PyObject *arg2 = (PyObject *) 0 ;
22678 PyObject *arg3 = (PyObject *) 0 ;
22679 PyObject * obj0 = 0 ;
22680 PyObject * obj1 = 0 ;
22681 PyObject * obj2 = 0 ;
22682 char *kwnames[] = {
22683 (char *) "self",(char *) "self",(char *) "_class", NULL
22684 };
22685
22686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(1)) SWIG_fail;
22689 arg2 = obj1;
22690 arg3 = obj2;
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 (arg1)->_setCallbackInfo(arg2,arg3);
22694
22695 wxPyEndAllowThreads(__tstate);
22696 if (PyErr_Occurred()) SWIG_fail;
22697 }
22698 Py_INCREF(Py_None); resultobj = Py_None;
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22706 PyObject *resultobj;
22707 wxPyApp *arg1 = (wxPyApp *) 0 ;
22708 wxString result;
22709 PyObject * obj0 = 0 ;
22710 char *kwnames[] = {
22711 (char *) "self", NULL
22712 };
22713
22714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22716 if (SWIG_arg_fail(1)) SWIG_fail;
22717 {
22718 PyThreadState* __tstate = wxPyBeginAllowThreads();
22719 result = ((wxPyApp const *)arg1)->GetAppName();
22720
22721 wxPyEndAllowThreads(__tstate);
22722 if (PyErr_Occurred()) SWIG_fail;
22723 }
22724 {
22725 #if wxUSE_UNICODE
22726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22727 #else
22728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22729 #endif
22730 }
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj;
22739 wxPyApp *arg1 = (wxPyApp *) 0 ;
22740 wxString *arg2 = 0 ;
22741 bool temp2 = false ;
22742 PyObject * obj0 = 0 ;
22743 PyObject * obj1 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self",(char *) "name", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 {
22752 arg2 = wxString_in_helper(obj1);
22753 if (arg2 == NULL) SWIG_fail;
22754 temp2 = true;
22755 }
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 (arg1)->SetAppName((wxString const &)*arg2);
22759
22760 wxPyEndAllowThreads(__tstate);
22761 if (PyErr_Occurred()) SWIG_fail;
22762 }
22763 Py_INCREF(Py_None); resultobj = Py_None;
22764 {
22765 if (temp2)
22766 delete arg2;
22767 }
22768 return resultobj;
22769 fail:
22770 {
22771 if (temp2)
22772 delete arg2;
22773 }
22774 return NULL;
22775 }
22776
22777
22778 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22779 PyObject *resultobj;
22780 wxPyApp *arg1 = (wxPyApp *) 0 ;
22781 wxString result;
22782 PyObject * obj0 = 0 ;
22783 char *kwnames[] = {
22784 (char *) "self", NULL
22785 };
22786
22787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22789 if (SWIG_arg_fail(1)) SWIG_fail;
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 result = ((wxPyApp const *)arg1)->GetClassName();
22793
22794 wxPyEndAllowThreads(__tstate);
22795 if (PyErr_Occurred()) SWIG_fail;
22796 }
22797 {
22798 #if wxUSE_UNICODE
22799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22800 #else
22801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22802 #endif
22803 }
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22811 PyObject *resultobj;
22812 wxPyApp *arg1 = (wxPyApp *) 0 ;
22813 wxString *arg2 = 0 ;
22814 bool temp2 = false ;
22815 PyObject * obj0 = 0 ;
22816 PyObject * obj1 = 0 ;
22817 char *kwnames[] = {
22818 (char *) "self",(char *) "name", NULL
22819 };
22820
22821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22823 if (SWIG_arg_fail(1)) SWIG_fail;
22824 {
22825 arg2 = wxString_in_helper(obj1);
22826 if (arg2 == NULL) SWIG_fail;
22827 temp2 = true;
22828 }
22829 {
22830 PyThreadState* __tstate = wxPyBeginAllowThreads();
22831 (arg1)->SetClassName((wxString const &)*arg2);
22832
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 Py_INCREF(Py_None); resultobj = Py_None;
22837 {
22838 if (temp2)
22839 delete arg2;
22840 }
22841 return resultobj;
22842 fail:
22843 {
22844 if (temp2)
22845 delete arg2;
22846 }
22847 return NULL;
22848 }
22849
22850
22851 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22852 PyObject *resultobj;
22853 wxPyApp *arg1 = (wxPyApp *) 0 ;
22854 wxString *result;
22855 PyObject * obj0 = 0 ;
22856 char *kwnames[] = {
22857 (char *) "self", NULL
22858 };
22859
22860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22862 if (SWIG_arg_fail(1)) SWIG_fail;
22863 {
22864 PyThreadState* __tstate = wxPyBeginAllowThreads();
22865 {
22866 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22867 result = (wxString *) &_result_ref;
22868 }
22869
22870 wxPyEndAllowThreads(__tstate);
22871 if (PyErr_Occurred()) SWIG_fail;
22872 }
22873 {
22874 #if wxUSE_UNICODE
22875 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22876 #else
22877 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22878 #endif
22879 }
22880 return resultobj;
22881 fail:
22882 return NULL;
22883 }
22884
22885
22886 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22887 PyObject *resultobj;
22888 wxPyApp *arg1 = (wxPyApp *) 0 ;
22889 wxString *arg2 = 0 ;
22890 bool temp2 = false ;
22891 PyObject * obj0 = 0 ;
22892 PyObject * obj1 = 0 ;
22893 char *kwnames[] = {
22894 (char *) "self",(char *) "name", NULL
22895 };
22896
22897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22899 if (SWIG_arg_fail(1)) SWIG_fail;
22900 {
22901 arg2 = wxString_in_helper(obj1);
22902 if (arg2 == NULL) SWIG_fail;
22903 temp2 = true;
22904 }
22905 {
22906 PyThreadState* __tstate = wxPyBeginAllowThreads();
22907 (arg1)->SetVendorName((wxString const &)*arg2);
22908
22909 wxPyEndAllowThreads(__tstate);
22910 if (PyErr_Occurred()) SWIG_fail;
22911 }
22912 Py_INCREF(Py_None); resultobj = Py_None;
22913 {
22914 if (temp2)
22915 delete arg2;
22916 }
22917 return resultobj;
22918 fail:
22919 {
22920 if (temp2)
22921 delete arg2;
22922 }
22923 return NULL;
22924 }
22925
22926
22927 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22928 PyObject *resultobj;
22929 wxPyApp *arg1 = (wxPyApp *) 0 ;
22930 wxAppTraits *result;
22931 PyObject * obj0 = 0 ;
22932 char *kwnames[] = {
22933 (char *) "self", NULL
22934 };
22935
22936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22938 if (SWIG_arg_fail(1)) SWIG_fail;
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 result = (wxAppTraits *)(arg1)->GetTraits();
22942
22943 wxPyEndAllowThreads(__tstate);
22944 if (PyErr_Occurred()) SWIG_fail;
22945 }
22946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22954 PyObject *resultobj;
22955 wxPyApp *arg1 = (wxPyApp *) 0 ;
22956 PyObject * obj0 = 0 ;
22957 char *kwnames[] = {
22958 (char *) "self", NULL
22959 };
22960
22961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22963 if (SWIG_arg_fail(1)) SWIG_fail;
22964 {
22965 PyThreadState* __tstate = wxPyBeginAllowThreads();
22966 (arg1)->ProcessPendingEvents();
22967
22968 wxPyEndAllowThreads(__tstate);
22969 if (PyErr_Occurred()) SWIG_fail;
22970 }
22971 Py_INCREF(Py_None); resultobj = Py_None;
22972 return resultobj;
22973 fail:
22974 return NULL;
22975 }
22976
22977
22978 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22979 PyObject *resultobj;
22980 wxPyApp *arg1 = (wxPyApp *) 0 ;
22981 bool arg2 = (bool) false ;
22982 bool result;
22983 PyObject * obj0 = 0 ;
22984 PyObject * obj1 = 0 ;
22985 char *kwnames[] = {
22986 (char *) "self",(char *) "onlyIfNeeded", NULL
22987 };
22988
22989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22991 if (SWIG_arg_fail(1)) SWIG_fail;
22992 if (obj1) {
22993 {
22994 arg2 = (bool)(SWIG_As_bool(obj1));
22995 if (SWIG_arg_fail(2)) SWIG_fail;
22996 }
22997 }
22998 {
22999 PyThreadState* __tstate = wxPyBeginAllowThreads();
23000 result = (bool)(arg1)->Yield(arg2);
23001
23002 wxPyEndAllowThreads(__tstate);
23003 if (PyErr_Occurred()) SWIG_fail;
23004 }
23005 {
23006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23007 }
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23015 PyObject *resultobj;
23016 wxPyApp *arg1 = (wxPyApp *) 0 ;
23017 PyObject * obj0 = 0 ;
23018 char *kwnames[] = {
23019 (char *) "self", NULL
23020 };
23021
23022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(1)) SWIG_fail;
23025 {
23026 PyThreadState* __tstate = wxPyBeginAllowThreads();
23027 (arg1)->WakeUpIdle();
23028
23029 wxPyEndAllowThreads(__tstate);
23030 if (PyErr_Occurred()) SWIG_fail;
23031 }
23032 Py_INCREF(Py_None); resultobj = Py_None;
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj;
23041 bool result;
23042 char *kwnames[] = {
23043 NULL
23044 };
23045
23046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 result = (bool)wxPyApp::IsMainLoopRunning();
23050
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 {
23055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23056 }
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxPyApp *arg1 = (wxPyApp *) 0 ;
23066 int result;
23067 PyObject * obj0 = 0 ;
23068 char *kwnames[] = {
23069 (char *) "self", NULL
23070 };
23071
23072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23074 if (SWIG_arg_fail(1)) SWIG_fail;
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (int)(arg1)->MainLoop();
23078
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 {
23083 resultobj = SWIG_From_int((int)(result));
23084 }
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj;
23093 wxPyApp *arg1 = (wxPyApp *) 0 ;
23094 PyObject * obj0 = 0 ;
23095 char *kwnames[] = {
23096 (char *) "self", NULL
23097 };
23098
23099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23101 if (SWIG_arg_fail(1)) SWIG_fail;
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 (arg1)->Exit();
23105
23106 wxPyEndAllowThreads(__tstate);
23107 if (PyErr_Occurred()) SWIG_fail;
23108 }
23109 Py_INCREF(Py_None); resultobj = Py_None;
23110 return resultobj;
23111 fail:
23112 return NULL;
23113 }
23114
23115
23116 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23117 PyObject *resultobj;
23118 wxPyApp *arg1 = (wxPyApp *) 0 ;
23119 PyObject * obj0 = 0 ;
23120 char *kwnames[] = {
23121 (char *) "self", NULL
23122 };
23123
23124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23126 if (SWIG_arg_fail(1)) SWIG_fail;
23127 {
23128 PyThreadState* __tstate = wxPyBeginAllowThreads();
23129 (arg1)->ExitMainLoop();
23130
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 Py_INCREF(Py_None); resultobj = Py_None;
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23142 PyObject *resultobj;
23143 wxPyApp *arg1 = (wxPyApp *) 0 ;
23144 bool result;
23145 PyObject * obj0 = 0 ;
23146 char *kwnames[] = {
23147 (char *) "self", NULL
23148 };
23149
23150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23152 if (SWIG_arg_fail(1)) SWIG_fail;
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (bool)(arg1)->Pending();
23156
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 {
23161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23162 }
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23170 PyObject *resultobj;
23171 wxPyApp *arg1 = (wxPyApp *) 0 ;
23172 bool result;
23173 PyObject * obj0 = 0 ;
23174 char *kwnames[] = {
23175 (char *) "self", NULL
23176 };
23177
23178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23180 if (SWIG_arg_fail(1)) SWIG_fail;
23181 {
23182 PyThreadState* __tstate = wxPyBeginAllowThreads();
23183 result = (bool)(arg1)->Dispatch();
23184
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23198 PyObject *resultobj;
23199 wxPyApp *arg1 = (wxPyApp *) 0 ;
23200 bool result;
23201 PyObject * obj0 = 0 ;
23202 char *kwnames[] = {
23203 (char *) "self", NULL
23204 };
23205
23206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23208 if (SWIG_arg_fail(1)) SWIG_fail;
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (bool)(arg1)->ProcessIdle();
23212
23213 wxPyEndAllowThreads(__tstate);
23214 if (PyErr_Occurred()) SWIG_fail;
23215 }
23216 {
23217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23218 }
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23226 PyObject *resultobj;
23227 wxPyApp *arg1 = (wxPyApp *) 0 ;
23228 wxWindow *arg2 = (wxWindow *) 0 ;
23229 wxIdleEvent *arg3 = 0 ;
23230 bool result;
23231 PyObject * obj0 = 0 ;
23232 PyObject * obj1 = 0 ;
23233 PyObject * obj2 = 0 ;
23234 char *kwnames[] = {
23235 (char *) "self",(char *) "win",(char *) "event", NULL
23236 };
23237
23238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23240 if (SWIG_arg_fail(1)) SWIG_fail;
23241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23242 if (SWIG_arg_fail(2)) SWIG_fail;
23243 {
23244 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23245 if (SWIG_arg_fail(3)) SWIG_fail;
23246 if (arg3 == NULL) {
23247 SWIG_null_ref("wxIdleEvent");
23248 }
23249 if (SWIG_arg_fail(3)) SWIG_fail;
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 {
23259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23260 }
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23268 PyObject *resultobj;
23269 wxPyApp *arg1 = (wxPyApp *) 0 ;
23270 bool result;
23271 PyObject * obj0 = 0 ;
23272 char *kwnames[] = {
23273 (char *) "self", NULL
23274 };
23275
23276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23278 if (SWIG_arg_fail(1)) SWIG_fail;
23279 {
23280 PyThreadState* __tstate = wxPyBeginAllowThreads();
23281 result = (bool)((wxPyApp const *)arg1)->IsActive();
23282
23283 wxPyEndAllowThreads(__tstate);
23284 if (PyErr_Occurred()) SWIG_fail;
23285 }
23286 {
23287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23288 }
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj;
23297 wxPyApp *arg1 = (wxPyApp *) 0 ;
23298 wxWindow *arg2 = (wxWindow *) 0 ;
23299 PyObject * obj0 = 0 ;
23300 PyObject * obj1 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self",(char *) "win", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(2)) SWIG_fail;
23310 {
23311 PyThreadState* __tstate = wxPyBeginAllowThreads();
23312 (arg1)->SetTopWindow(arg2);
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_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23325 PyObject *resultobj;
23326 wxPyApp *arg1 = (wxPyApp *) 0 ;
23327 wxWindow *result;
23328 PyObject * obj0 = 0 ;
23329 char *kwnames[] = {
23330 (char *) "self", NULL
23331 };
23332
23333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23335 if (SWIG_arg_fail(1)) SWIG_fail;
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23339
23340 wxPyEndAllowThreads(__tstate);
23341 if (PyErr_Occurred()) SWIG_fail;
23342 }
23343 {
23344 resultobj = wxPyMake_wxObject(result, 0);
23345 }
23346 return resultobj;
23347 fail:
23348 return NULL;
23349 }
23350
23351
23352 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23353 PyObject *resultobj;
23354 wxPyApp *arg1 = (wxPyApp *) 0 ;
23355 bool arg2 ;
23356 PyObject * obj0 = 0 ;
23357 PyObject * obj1 = 0 ;
23358 char *kwnames[] = {
23359 (char *) "self",(char *) "flag", NULL
23360 };
23361
23362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23364 if (SWIG_arg_fail(1)) SWIG_fail;
23365 {
23366 arg2 = (bool)(SWIG_As_bool(obj1));
23367 if (SWIG_arg_fail(2)) SWIG_fail;
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 (arg1)->SetExitOnFrameDelete(arg2);
23372
23373 wxPyEndAllowThreads(__tstate);
23374 if (PyErr_Occurred()) SWIG_fail;
23375 }
23376 Py_INCREF(Py_None); resultobj = Py_None;
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxPyApp *arg1 = (wxPyApp *) 0 ;
23386 bool result;
23387 PyObject * obj0 = 0 ;
23388 char *kwnames[] = {
23389 (char *) "self", NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23394 if (SWIG_arg_fail(1)) SWIG_fail;
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23398
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23412 PyObject *resultobj;
23413 wxPyApp *arg1 = (wxPyApp *) 0 ;
23414 bool arg2 ;
23415 PyObject * obj0 = 0 ;
23416 PyObject * obj1 = 0 ;
23417 char *kwnames[] = {
23418 (char *) "self",(char *) "flag", NULL
23419 };
23420
23421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23423 if (SWIG_arg_fail(1)) SWIG_fail;
23424 {
23425 arg2 = (bool)(SWIG_As_bool(obj1));
23426 if (SWIG_arg_fail(2)) SWIG_fail;
23427 }
23428 {
23429 PyThreadState* __tstate = wxPyBeginAllowThreads();
23430 (arg1)->SetUseBestVisual(arg2);
23431
23432 wxPyEndAllowThreads(__tstate);
23433 if (PyErr_Occurred()) SWIG_fail;
23434 }
23435 Py_INCREF(Py_None); resultobj = Py_None;
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 wxPyApp *arg1 = (wxPyApp *) 0 ;
23445 bool result;
23446 PyObject * obj0 = 0 ;
23447 char *kwnames[] = {
23448 (char *) "self", NULL
23449 };
23450
23451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23453 if (SWIG_arg_fail(1)) SWIG_fail;
23454 {
23455 PyThreadState* __tstate = wxPyBeginAllowThreads();
23456 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23457
23458 wxPyEndAllowThreads(__tstate);
23459 if (PyErr_Occurred()) SWIG_fail;
23460 }
23461 {
23462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23463 }
23464 return resultobj;
23465 fail:
23466 return NULL;
23467 }
23468
23469
23470 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23471 PyObject *resultobj;
23472 wxPyApp *arg1 = (wxPyApp *) 0 ;
23473 int arg2 ;
23474 PyObject * obj0 = 0 ;
23475 PyObject * obj1 = 0 ;
23476 char *kwnames[] = {
23477 (char *) "self",(char *) "mode", NULL
23478 };
23479
23480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23482 if (SWIG_arg_fail(1)) SWIG_fail;
23483 {
23484 arg2 = (int)(SWIG_As_int(obj1));
23485 if (SWIG_arg_fail(2)) SWIG_fail;
23486 }
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 (arg1)->SetPrintMode(arg2);
23490
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 Py_INCREF(Py_None); resultobj = Py_None;
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj;
23503 wxPyApp *arg1 = (wxPyApp *) 0 ;
23504 int result;
23505 PyObject * obj0 = 0 ;
23506 char *kwnames[] = {
23507 (char *) "self", NULL
23508 };
23509
23510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23512 if (SWIG_arg_fail(1)) SWIG_fail;
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23516
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 {
23521 resultobj = SWIG_From_int((int)(result));
23522 }
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23530 PyObject *resultobj;
23531 wxPyApp *arg1 = (wxPyApp *) 0 ;
23532 int arg2 ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char *kwnames[] = {
23536 (char *) "self",(char *) "mode", NULL
23537 };
23538
23539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(1)) SWIG_fail;
23542 {
23543 arg2 = (int)(SWIG_As_int(obj1));
23544 if (SWIG_arg_fail(2)) SWIG_fail;
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 (arg1)->SetAssertMode(arg2);
23549
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 Py_INCREF(Py_None); resultobj = Py_None;
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj;
23562 wxPyApp *arg1 = (wxPyApp *) 0 ;
23563 int result;
23564 PyObject * obj0 = 0 ;
23565 char *kwnames[] = {
23566 (char *) "self", NULL
23567 };
23568
23569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23571 if (SWIG_arg_fail(1)) SWIG_fail;
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (int)(arg1)->GetAssertMode();
23575
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 {
23580 resultobj = SWIG_From_int((int)(result));
23581 }
23582 return resultobj;
23583 fail:
23584 return NULL;
23585 }
23586
23587
23588 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23589 PyObject *resultobj;
23590 bool result;
23591 char *kwnames[] = {
23592 NULL
23593 };
23594
23595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23596 {
23597 PyThreadState* __tstate = wxPyBeginAllowThreads();
23598 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23599
23600 wxPyEndAllowThreads(__tstate);
23601 if (PyErr_Occurred()) SWIG_fail;
23602 }
23603 {
23604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23605 }
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23613 PyObject *resultobj;
23614 long result;
23615 char *kwnames[] = {
23616 NULL
23617 };
23618
23619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 result = (long)wxPyApp::GetMacAboutMenuItemId();
23623
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 {
23628 resultobj = SWIG_From_long((long)(result));
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23637 PyObject *resultobj;
23638 long result;
23639 char *kwnames[] = {
23640 NULL
23641 };
23642
23643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23647
23648 wxPyEndAllowThreads(__tstate);
23649 if (PyErr_Occurred()) SWIG_fail;
23650 }
23651 {
23652 resultobj = SWIG_From_long((long)(result));
23653 }
23654 return resultobj;
23655 fail:
23656 return NULL;
23657 }
23658
23659
23660 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23661 PyObject *resultobj;
23662 long result;
23663 char *kwnames[] = {
23664 NULL
23665 };
23666
23667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23668 {
23669 PyThreadState* __tstate = wxPyBeginAllowThreads();
23670 result = (long)wxPyApp::GetMacExitMenuItemId();
23671
23672 wxPyEndAllowThreads(__tstate);
23673 if (PyErr_Occurred()) SWIG_fail;
23674 }
23675 {
23676 resultobj = SWIG_From_long((long)(result));
23677 }
23678 return resultobj;
23679 fail:
23680 return NULL;
23681 }
23682
23683
23684 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23685 PyObject *resultobj;
23686 wxString result;
23687 char *kwnames[] = {
23688 NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = wxPyApp::GetMacHelpMenuTitleName();
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 #if wxUSE_UNICODE
23701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23702 #else
23703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23704 #endif
23705 }
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23713 PyObject *resultobj;
23714 bool arg1 ;
23715 PyObject * obj0 = 0 ;
23716 char *kwnames[] = {
23717 (char *) "val", NULL
23718 };
23719
23720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23721 {
23722 arg1 = (bool)(SWIG_As_bool(obj0));
23723 if (SWIG_arg_fail(1)) SWIG_fail;
23724 }
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23728
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 Py_INCREF(Py_None); resultobj = Py_None;
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj;
23741 long arg1 ;
23742 PyObject * obj0 = 0 ;
23743 char *kwnames[] = {
23744 (char *) "val", NULL
23745 };
23746
23747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23748 {
23749 arg1 = (long)(SWIG_As_long(obj0));
23750 if (SWIG_arg_fail(1)) SWIG_fail;
23751 }
23752 {
23753 PyThreadState* __tstate = wxPyBeginAllowThreads();
23754 wxPyApp::SetMacAboutMenuItemId(arg1);
23755
23756 wxPyEndAllowThreads(__tstate);
23757 if (PyErr_Occurred()) SWIG_fail;
23758 }
23759 Py_INCREF(Py_None); resultobj = Py_None;
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23767 PyObject *resultobj;
23768 long arg1 ;
23769 PyObject * obj0 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "val", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23775 {
23776 arg1 = (long)(SWIG_As_long(obj0));
23777 if (SWIG_arg_fail(1)) SWIG_fail;
23778 }
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 Py_INCREF(Py_None); resultobj = Py_None;
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj;
23795 long arg1 ;
23796 PyObject * obj0 = 0 ;
23797 char *kwnames[] = {
23798 (char *) "val", NULL
23799 };
23800
23801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23802 {
23803 arg1 = (long)(SWIG_As_long(obj0));
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 }
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 wxPyApp::SetMacExitMenuItemId(arg1);
23809
23810 wxPyEndAllowThreads(__tstate);
23811 if (PyErr_Occurred()) SWIG_fail;
23812 }
23813 Py_INCREF(Py_None); resultobj = Py_None;
23814 return resultobj;
23815 fail:
23816 return NULL;
23817 }
23818
23819
23820 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj;
23822 wxString *arg1 = 0 ;
23823 bool temp1 = false ;
23824 PyObject * obj0 = 0 ;
23825 char *kwnames[] = {
23826 (char *) "val", NULL
23827 };
23828
23829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23830 {
23831 arg1 = wxString_in_helper(obj0);
23832 if (arg1 == NULL) SWIG_fail;
23833 temp1 = true;
23834 }
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23838
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 Py_INCREF(Py_None); resultobj = Py_None;
23843 {
23844 if (temp1)
23845 delete arg1;
23846 }
23847 return resultobj;
23848 fail:
23849 {
23850 if (temp1)
23851 delete arg1;
23852 }
23853 return NULL;
23854 }
23855
23856
23857 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj;
23859 wxPyApp *arg1 = (wxPyApp *) 0 ;
23860 PyObject * obj0 = 0 ;
23861 char *kwnames[] = {
23862 (char *) "self", NULL
23863 };
23864
23865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23867 if (SWIG_arg_fail(1)) SWIG_fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 (arg1)->_BootstrapApp();
23871
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 Py_INCREF(Py_None); resultobj = Py_None;
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj;
23884 int result;
23885 char *kwnames[] = {
23886 NULL
23887 };
23888
23889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23890 {
23891 PyThreadState* __tstate = wxPyBeginAllowThreads();
23892 result = (int)PyApp_GetComCtl32Version();
23893
23894 wxPyEndAllowThreads(__tstate);
23895 if (PyErr_Occurred()) SWIG_fail;
23896 }
23897 {
23898 resultobj = SWIG_From_int((int)(result));
23899 }
23900 return resultobj;
23901 fail:
23902 return NULL;
23903 }
23904
23905
23906 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23907 PyObject *obj;
23908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23909 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23910 Py_INCREF(obj);
23911 return Py_BuildValue((char *)"");
23912 }
23913 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj;
23915 char *kwnames[] = {
23916 NULL
23917 };
23918
23919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 wxExit();
23923
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 Py_INCREF(Py_None); resultobj = Py_None;
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23935 PyObject *resultobj;
23936 bool result;
23937 char *kwnames[] = {
23938 NULL
23939 };
23940
23941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23942 {
23943 PyThreadState* __tstate = wxPyBeginAllowThreads();
23944 result = (bool)wxYield();
23945
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 {
23950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23951 }
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj;
23960 bool result;
23961 char *kwnames[] = {
23962 NULL
23963 };
23964
23965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = (bool)wxYieldIfNeeded();
23969
23970 wxPyEndAllowThreads(__tstate);
23971 if (PyErr_Occurred()) SWIG_fail;
23972 }
23973 {
23974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23975 }
23976 return resultobj;
23977 fail:
23978 return NULL;
23979 }
23980
23981
23982 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23983 PyObject *resultobj;
23984 wxWindow *arg1 = (wxWindow *) NULL ;
23985 bool arg2 = (bool) false ;
23986 bool result;
23987 PyObject * obj0 = 0 ;
23988 PyObject * obj1 = 0 ;
23989 char *kwnames[] = {
23990 (char *) "win",(char *) "onlyIfNeeded", NULL
23991 };
23992
23993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23994 if (obj0) {
23995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23996 if (SWIG_arg_fail(1)) SWIG_fail;
23997 }
23998 if (obj1) {
23999 {
24000 arg2 = (bool)(SWIG_As_bool(obj1));
24001 if (SWIG_arg_fail(2)) SWIG_fail;
24002 }
24003 }
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (bool)wxSafeYield(arg1,arg2);
24007
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 {
24012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24013 }
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24021 PyObject *resultobj;
24022 char *kwnames[] = {
24023 NULL
24024 };
24025
24026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24027 {
24028 PyThreadState* __tstate = wxPyBeginAllowThreads();
24029 wxWakeUpIdle();
24030
24031 wxPyEndAllowThreads(__tstate);
24032 if (PyErr_Occurred()) SWIG_fail;
24033 }
24034 Py_INCREF(Py_None); resultobj = Py_None;
24035 return resultobj;
24036 fail:
24037 return NULL;
24038 }
24039
24040
24041 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24042 PyObject *resultobj;
24043 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24044 wxEvent *arg2 = 0 ;
24045 PyObject * obj0 = 0 ;
24046 PyObject * obj1 = 0 ;
24047 char *kwnames[] = {
24048 (char *) "dest",(char *) "event", NULL
24049 };
24050
24051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24053 if (SWIG_arg_fail(1)) SWIG_fail;
24054 {
24055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24056 if (SWIG_arg_fail(2)) SWIG_fail;
24057 if (arg2 == NULL) {
24058 SWIG_null_ref("wxEvent");
24059 }
24060 if (SWIG_arg_fail(2)) SWIG_fail;
24061 }
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 wxPostEvent(arg1,*arg2);
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 Py_INCREF(Py_None); resultobj = Py_None;
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj;
24078 char *kwnames[] = {
24079 NULL
24080 };
24081
24082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 wxApp_CleanUp();
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxPyApp *result;
24100 char *kwnames[] = {
24101 NULL
24102 };
24103
24104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24105 {
24106 PyThreadState* __tstate = wxPyBeginAllowThreads();
24107 result = (wxPyApp *)wxPyGetApp();
24108
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 {
24113 resultobj = wxPyMake_wxObject(result, 0);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24122 PyObject *resultobj;
24123 char *arg1 = (char *) 0 ;
24124 PyObject * obj0 = 0 ;
24125 char *kwnames[] = {
24126 (char *) "encoding", NULL
24127 };
24128
24129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24130 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24131 SWIG_arg_fail(1);SWIG_fail;
24132 }
24133 {
24134 PyThreadState* __tstate = wxPyBeginAllowThreads();
24135 wxSetDefaultPyEncoding((char const *)arg1);
24136
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 Py_INCREF(Py_None); resultobj = Py_None;
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 char *result;
24150 char *kwnames[] = {
24151 NULL
24152 };
24153
24154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 result = (char *)wxGetDefaultPyEncoding();
24158
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 resultobj = SWIG_FromCharPtr(result);
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj;
24171 wxEventLoop *result;
24172 char *kwnames[] = {
24173 NULL
24174 };
24175
24176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24177 {
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 result = (wxEventLoop *)new wxEventLoop();
24180
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24185 return resultobj;
24186 fail:
24187 return NULL;
24188 }
24189
24190
24191 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24192 PyObject *resultobj;
24193 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24194 PyObject * obj0 = 0 ;
24195 char *kwnames[] = {
24196 (char *) "self", NULL
24197 };
24198
24199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24201 if (SWIG_arg_fail(1)) SWIG_fail;
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 delete arg1;
24205
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 Py_INCREF(Py_None); resultobj = Py_None;
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24217 PyObject *resultobj;
24218 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24219 int result;
24220 PyObject * obj0 = 0 ;
24221 char *kwnames[] = {
24222 (char *) "self", NULL
24223 };
24224
24225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24227 if (SWIG_arg_fail(1)) SWIG_fail;
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (int)(arg1)->Run();
24231
24232 wxPyEndAllowThreads(__tstate);
24233 if (PyErr_Occurred()) SWIG_fail;
24234 }
24235 {
24236 resultobj = SWIG_From_int((int)(result));
24237 }
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24245 PyObject *resultobj;
24246 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24247 int arg2 = (int) 0 ;
24248 PyObject * obj0 = 0 ;
24249 PyObject * obj1 = 0 ;
24250 char *kwnames[] = {
24251 (char *) "self",(char *) "rc", NULL
24252 };
24253
24254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24256 if (SWIG_arg_fail(1)) SWIG_fail;
24257 if (obj1) {
24258 {
24259 arg2 = (int)(SWIG_As_int(obj1));
24260 if (SWIG_arg_fail(2)) SWIG_fail;
24261 }
24262 }
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 (arg1)->Exit(arg2);
24266
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 Py_INCREF(Py_None); resultobj = Py_None;
24271 return resultobj;
24272 fail:
24273 return NULL;
24274 }
24275
24276
24277 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24278 PyObject *resultobj;
24279 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24280 bool result;
24281 PyObject * obj0 = 0 ;
24282 char *kwnames[] = {
24283 (char *) "self", NULL
24284 };
24285
24286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24288 if (SWIG_arg_fail(1)) SWIG_fail;
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 result = (bool)((wxEventLoop const *)arg1)->Pending();
24292
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 {
24297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24298 }
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj;
24307 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24308 bool result;
24309 PyObject * obj0 = 0 ;
24310 char *kwnames[] = {
24311 (char *) "self", NULL
24312 };
24313
24314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24316 if (SWIG_arg_fail(1)) SWIG_fail;
24317 {
24318 PyThreadState* __tstate = wxPyBeginAllowThreads();
24319 result = (bool)(arg1)->Dispatch();
24320
24321 wxPyEndAllowThreads(__tstate);
24322 if (PyErr_Occurred()) SWIG_fail;
24323 }
24324 {
24325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24326 }
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24334 PyObject *resultobj;
24335 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24336 bool result;
24337 PyObject * obj0 = 0 ;
24338 char *kwnames[] = {
24339 (char *) "self", NULL
24340 };
24341
24342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24344 if (SWIG_arg_fail(1)) SWIG_fail;
24345 {
24346 PyThreadState* __tstate = wxPyBeginAllowThreads();
24347 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24348
24349 wxPyEndAllowThreads(__tstate);
24350 if (PyErr_Occurred()) SWIG_fail;
24351 }
24352 {
24353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24354 }
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24362 PyObject *resultobj;
24363 wxEventLoop *result;
24364 char *kwnames[] = {
24365 NULL
24366 };
24367
24368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24369 {
24370 PyThreadState* __tstate = wxPyBeginAllowThreads();
24371 result = (wxEventLoop *)wxEventLoop::GetActive();
24372
24373 wxPyEndAllowThreads(__tstate);
24374 if (PyErr_Occurred()) SWIG_fail;
24375 }
24376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24377 return resultobj;
24378 fail:
24379 return NULL;
24380 }
24381
24382
24383 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24384 PyObject *resultobj;
24385 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24386 PyObject * obj0 = 0 ;
24387 char *kwnames[] = {
24388 (char *) "loop", NULL
24389 };
24390
24391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(1)) SWIG_fail;
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 wxEventLoop::SetActive(arg1);
24397
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 Py_INCREF(Py_None); resultobj = Py_None;
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24409 PyObject *obj;
24410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24411 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24412 Py_INCREF(obj);
24413 return Py_BuildValue((char *)"");
24414 }
24415 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj;
24417 int arg1 = (int) 0 ;
24418 int arg2 = (int) 0 ;
24419 int arg3 = (int) 0 ;
24420 wxAcceleratorEntry *result;
24421 PyObject * obj0 = 0 ;
24422 PyObject * obj1 = 0 ;
24423 PyObject * obj2 = 0 ;
24424 char *kwnames[] = {
24425 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24426 };
24427
24428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24429 if (obj0) {
24430 {
24431 arg1 = (int)(SWIG_As_int(obj0));
24432 if (SWIG_arg_fail(1)) SWIG_fail;
24433 }
24434 }
24435 if (obj1) {
24436 {
24437 arg2 = (int)(SWIG_As_int(obj1));
24438 if (SWIG_arg_fail(2)) SWIG_fail;
24439 }
24440 }
24441 if (obj2) {
24442 {
24443 arg3 = (int)(SWIG_As_int(obj2));
24444 if (SWIG_arg_fail(3)) SWIG_fail;
24445 }
24446 }
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24450
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24462 PyObject *resultobj;
24463 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24464 PyObject * obj0 = 0 ;
24465 char *kwnames[] = {
24466 (char *) "self", NULL
24467 };
24468
24469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24471 if (SWIG_arg_fail(1)) SWIG_fail;
24472 {
24473 PyThreadState* __tstate = wxPyBeginAllowThreads();
24474 delete arg1;
24475
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 Py_INCREF(Py_None); resultobj = Py_None;
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj;
24488 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24489 int arg2 ;
24490 int arg3 ;
24491 int arg4 ;
24492 PyObject * obj0 = 0 ;
24493 PyObject * obj1 = 0 ;
24494 PyObject * obj2 = 0 ;
24495 PyObject * obj3 = 0 ;
24496 char *kwnames[] = {
24497 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24498 };
24499
24500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24502 if (SWIG_arg_fail(1)) SWIG_fail;
24503 {
24504 arg2 = (int)(SWIG_As_int(obj1));
24505 if (SWIG_arg_fail(2)) SWIG_fail;
24506 }
24507 {
24508 arg3 = (int)(SWIG_As_int(obj2));
24509 if (SWIG_arg_fail(3)) SWIG_fail;
24510 }
24511 {
24512 arg4 = (int)(SWIG_As_int(obj3));
24513 if (SWIG_arg_fail(4)) SWIG_fail;
24514 }
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 (arg1)->Set(arg2,arg3,arg4);
24518
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 Py_INCREF(Py_None); resultobj = Py_None;
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24530 PyObject *resultobj;
24531 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24532 int result;
24533 PyObject * obj0 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "self", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24540 if (SWIG_arg_fail(1)) SWIG_fail;
24541 {
24542 PyThreadState* __tstate = wxPyBeginAllowThreads();
24543 result = (int)(arg1)->GetFlags();
24544
24545 wxPyEndAllowThreads(__tstate);
24546 if (PyErr_Occurred()) SWIG_fail;
24547 }
24548 {
24549 resultobj = SWIG_From_int((int)(result));
24550 }
24551 return resultobj;
24552 fail:
24553 return NULL;
24554 }
24555
24556
24557 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24558 PyObject *resultobj;
24559 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24560 int result;
24561 PyObject * obj0 = 0 ;
24562 char *kwnames[] = {
24563 (char *) "self", NULL
24564 };
24565
24566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24568 if (SWIG_arg_fail(1)) SWIG_fail;
24569 {
24570 PyThreadState* __tstate = wxPyBeginAllowThreads();
24571 result = (int)(arg1)->GetKeyCode();
24572
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 {
24577 resultobj = SWIG_From_int((int)(result));
24578 }
24579 return resultobj;
24580 fail:
24581 return NULL;
24582 }
24583
24584
24585 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24586 PyObject *resultobj;
24587 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24588 int result;
24589 PyObject * obj0 = 0 ;
24590 char *kwnames[] = {
24591 (char *) "self", NULL
24592 };
24593
24594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24596 if (SWIG_arg_fail(1)) SWIG_fail;
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = (int)(arg1)->GetCommand();
24600
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 {
24605 resultobj = SWIG_From_int((int)(result));
24606 }
24607 return resultobj;
24608 fail:
24609 return NULL;
24610 }
24611
24612
24613 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24614 PyObject *obj;
24615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24616 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24617 Py_INCREF(obj);
24618 return Py_BuildValue((char *)"");
24619 }
24620 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24621 PyObject *resultobj;
24622 int arg1 ;
24623 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24624 wxAcceleratorTable *result;
24625 PyObject * obj0 = 0 ;
24626 char *kwnames[] = {
24627 (char *) "n", NULL
24628 };
24629
24630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24631 {
24632 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24633 if (arg2) arg1 = PyList_Size(obj0);
24634 else arg1 = 0;
24635 }
24636 {
24637 PyThreadState* __tstate = wxPyBeginAllowThreads();
24638 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24639
24640 wxPyEndAllowThreads(__tstate);
24641 if (PyErr_Occurred()) SWIG_fail;
24642 }
24643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24644 {
24645 delete [] arg2;
24646 }
24647 return resultobj;
24648 fail:
24649 {
24650 delete [] arg2;
24651 }
24652 return NULL;
24653 }
24654
24655
24656 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj;
24658 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24659 PyObject * obj0 = 0 ;
24660 char *kwnames[] = {
24661 (char *) "self", NULL
24662 };
24663
24664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24666 if (SWIG_arg_fail(1)) SWIG_fail;
24667 {
24668 PyThreadState* __tstate = wxPyBeginAllowThreads();
24669 delete arg1;
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 Py_INCREF(Py_None); resultobj = Py_None;
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj;
24683 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24684 bool result;
24685 PyObject * obj0 = 0 ;
24686 char *kwnames[] = {
24687 (char *) "self", NULL
24688 };
24689
24690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24692 if (SWIG_arg_fail(1)) SWIG_fail;
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
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 * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24710 PyObject *obj;
24711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24712 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24713 Py_INCREF(obj);
24714 return Py_BuildValue((char *)"");
24715 }
24716 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24717 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24718 return 1;
24719 }
24720
24721
24722 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24723 PyObject *pyobj;
24724
24725 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24726 return pyobj;
24727 }
24728
24729
24730 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24731 PyObject *resultobj;
24732 wxString *arg1 = 0 ;
24733 wxAcceleratorEntry *result;
24734 bool temp1 = false ;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "label", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24741 {
24742 arg1 = wxString_in_helper(obj0);
24743 if (arg1 == NULL) SWIG_fail;
24744 temp1 = true;
24745 }
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24749
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24754 {
24755 if (temp1)
24756 delete arg1;
24757 }
24758 return resultobj;
24759 fail:
24760 {
24761 if (temp1)
24762 delete arg1;
24763 }
24764 return NULL;
24765 }
24766
24767
24768 static int _wrap_PanelNameStr_set(PyObject *) {
24769 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24770 return 1;
24771 }
24772
24773
24774 static PyObject *_wrap_PanelNameStr_get(void) {
24775 PyObject *pyobj;
24776
24777 {
24778 #if wxUSE_UNICODE
24779 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24780 #else
24781 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24782 #endif
24783 }
24784 return pyobj;
24785 }
24786
24787
24788 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxVisualAttributes *result;
24791 char *kwnames[] = {
24792 NULL
24793 };
24794
24795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24796 {
24797 PyThreadState* __tstate = wxPyBeginAllowThreads();
24798 result = (wxVisualAttributes *)new_wxVisualAttributes();
24799
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj;
24812 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24813 PyObject * obj0 = 0 ;
24814 char *kwnames[] = {
24815 (char *) "self", NULL
24816 };
24817
24818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24820 if (SWIG_arg_fail(1)) SWIG_fail;
24821 {
24822 PyThreadState* __tstate = wxPyBeginAllowThreads();
24823 delete_wxVisualAttributes(arg1);
24824
24825 wxPyEndAllowThreads(__tstate);
24826 if (PyErr_Occurred()) SWIG_fail;
24827 }
24828 Py_INCREF(Py_None); resultobj = Py_None;
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24836 PyObject *resultobj;
24837 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24838 wxFont *arg2 = (wxFont *) 0 ;
24839 PyObject * obj0 = 0 ;
24840 PyObject * obj1 = 0 ;
24841 char *kwnames[] = {
24842 (char *) "self",(char *) "font", NULL
24843 };
24844
24845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24847 if (SWIG_arg_fail(1)) SWIG_fail;
24848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(2)) SWIG_fail;
24850 if (arg1) (arg1)->font = *arg2;
24851
24852 Py_INCREF(Py_None); resultobj = Py_None;
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24860 PyObject *resultobj;
24861 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24862 wxFont *result;
24863 PyObject * obj0 = 0 ;
24864 char *kwnames[] = {
24865 (char *) "self", NULL
24866 };
24867
24868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24870 if (SWIG_arg_fail(1)) SWIG_fail;
24871 result = (wxFont *)& ((arg1)->font);
24872
24873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24883 wxColour *arg2 = (wxColour *) 0 ;
24884 PyObject * obj0 = 0 ;
24885 PyObject * obj1 = 0 ;
24886 char *kwnames[] = {
24887 (char *) "self",(char *) "colFg", NULL
24888 };
24889
24890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24892 if (SWIG_arg_fail(1)) SWIG_fail;
24893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(2)) SWIG_fail;
24895 if (arg1) (arg1)->colFg = *arg2;
24896
24897 Py_INCREF(Py_None); resultobj = Py_None;
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj;
24906 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24907 wxColour *result;
24908 PyObject * obj0 = 0 ;
24909 char *kwnames[] = {
24910 (char *) "self", NULL
24911 };
24912
24913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24915 if (SWIG_arg_fail(1)) SWIG_fail;
24916 result = (wxColour *)& ((arg1)->colFg);
24917
24918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24926 PyObject *resultobj;
24927 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24928 wxColour *arg2 = (wxColour *) 0 ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char *kwnames[] = {
24932 (char *) "self",(char *) "colBg", NULL
24933 };
24934
24935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24937 if (SWIG_arg_fail(1)) SWIG_fail;
24938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(2)) SWIG_fail;
24940 if (arg1) (arg1)->colBg = *arg2;
24941
24942 Py_INCREF(Py_None); resultobj = Py_None;
24943 return resultobj;
24944 fail:
24945 return NULL;
24946 }
24947
24948
24949 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24950 PyObject *resultobj;
24951 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24952 wxColour *result;
24953 PyObject * obj0 = 0 ;
24954 char *kwnames[] = {
24955 (char *) "self", NULL
24956 };
24957
24958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24960 if (SWIG_arg_fail(1)) SWIG_fail;
24961 result = (wxColour *)& ((arg1)->colBg);
24962
24963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24971 PyObject *obj;
24972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24973 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24974 Py_INCREF(obj);
24975 return Py_BuildValue((char *)"");
24976 }
24977 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj;
24979 wxWindow *arg1 = (wxWindow *) 0 ;
24980 int arg2 = (int) (int)-1 ;
24981 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24982 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24983 wxSize const &arg4_defvalue = wxDefaultSize ;
24984 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24985 long arg5 = (long) 0 ;
24986 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24987 wxString *arg6 = (wxString *) &arg6_defvalue ;
24988 wxWindow *result;
24989 wxPoint temp3 ;
24990 wxSize temp4 ;
24991 bool temp6 = false ;
24992 PyObject * obj0 = 0 ;
24993 PyObject * obj1 = 0 ;
24994 PyObject * obj2 = 0 ;
24995 PyObject * obj3 = 0 ;
24996 PyObject * obj4 = 0 ;
24997 PyObject * obj5 = 0 ;
24998 char *kwnames[] = {
24999 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25000 };
25001
25002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25004 if (SWIG_arg_fail(1)) SWIG_fail;
25005 if (obj1) {
25006 {
25007 arg2 = (int const)(SWIG_As_int(obj1));
25008 if (SWIG_arg_fail(2)) SWIG_fail;
25009 }
25010 }
25011 if (obj2) {
25012 {
25013 arg3 = &temp3;
25014 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25015 }
25016 }
25017 if (obj3) {
25018 {
25019 arg4 = &temp4;
25020 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25021 }
25022 }
25023 if (obj4) {
25024 {
25025 arg5 = (long)(SWIG_As_long(obj4));
25026 if (SWIG_arg_fail(5)) SWIG_fail;
25027 }
25028 }
25029 if (obj5) {
25030 {
25031 arg6 = wxString_in_helper(obj5);
25032 if (arg6 == NULL) SWIG_fail;
25033 temp6 = true;
25034 }
25035 }
25036 {
25037 if (!wxPyCheckForApp()) SWIG_fail;
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25040
25041 wxPyEndAllowThreads(__tstate);
25042 if (PyErr_Occurred()) SWIG_fail;
25043 }
25044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25045 {
25046 if (temp6)
25047 delete arg6;
25048 }
25049 return resultobj;
25050 fail:
25051 {
25052 if (temp6)
25053 delete arg6;
25054 }
25055 return NULL;
25056 }
25057
25058
25059 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj;
25061 wxWindow *result;
25062 char *kwnames[] = {
25063 NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25067 {
25068 if (!wxPyCheckForApp()) SWIG_fail;
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 result = (wxWindow *)new wxWindow();
25071
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj;
25084 wxWindow *arg1 = (wxWindow *) 0 ;
25085 wxWindow *arg2 = (wxWindow *) 0 ;
25086 int arg3 = (int) (int)-1 ;
25087 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25088 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25089 wxSize const &arg5_defvalue = wxDefaultSize ;
25090 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25091 long arg6 = (long) 0 ;
25092 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25093 wxString *arg7 = (wxString *) &arg7_defvalue ;
25094 bool result;
25095 wxPoint temp4 ;
25096 wxSize temp5 ;
25097 bool temp7 = false ;
25098 PyObject * obj0 = 0 ;
25099 PyObject * obj1 = 0 ;
25100 PyObject * obj2 = 0 ;
25101 PyObject * obj3 = 0 ;
25102 PyObject * obj4 = 0 ;
25103 PyObject * obj5 = 0 ;
25104 PyObject * obj6 = 0 ;
25105 char *kwnames[] = {
25106 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25107 };
25108
25109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(2)) SWIG_fail;
25114 if (obj2) {
25115 {
25116 arg3 = (int const)(SWIG_As_int(obj2));
25117 if (SWIG_arg_fail(3)) SWIG_fail;
25118 }
25119 }
25120 if (obj3) {
25121 {
25122 arg4 = &temp4;
25123 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25124 }
25125 }
25126 if (obj4) {
25127 {
25128 arg5 = &temp5;
25129 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25130 }
25131 }
25132 if (obj5) {
25133 {
25134 arg6 = (long)(SWIG_As_long(obj5));
25135 if (SWIG_arg_fail(6)) SWIG_fail;
25136 }
25137 }
25138 if (obj6) {
25139 {
25140 arg7 = wxString_in_helper(obj6);
25141 if (arg7 == NULL) SWIG_fail;
25142 temp7 = true;
25143 }
25144 }
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25154 }
25155 {
25156 if (temp7)
25157 delete arg7;
25158 }
25159 return resultobj;
25160 fail:
25161 {
25162 if (temp7)
25163 delete arg7;
25164 }
25165 return NULL;
25166 }
25167
25168
25169 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25170 PyObject *resultobj;
25171 wxWindow *arg1 = (wxWindow *) 0 ;
25172 bool arg2 = (bool) false ;
25173 bool result;
25174 PyObject * obj0 = 0 ;
25175 PyObject * obj1 = 0 ;
25176 char *kwnames[] = {
25177 (char *) "self",(char *) "force", NULL
25178 };
25179
25180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25182 if (SWIG_arg_fail(1)) SWIG_fail;
25183 if (obj1) {
25184 {
25185 arg2 = (bool)(SWIG_As_bool(obj1));
25186 if (SWIG_arg_fail(2)) SWIG_fail;
25187 }
25188 }
25189 {
25190 PyThreadState* __tstate = wxPyBeginAllowThreads();
25191 result = (bool)(arg1)->Close(arg2);
25192
25193 wxPyEndAllowThreads(__tstate);
25194 if (PyErr_Occurred()) SWIG_fail;
25195 }
25196 {
25197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25198 }
25199 return resultobj;
25200 fail:
25201 return NULL;
25202 }
25203
25204
25205 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25206 PyObject *resultobj;
25207 wxWindow *arg1 = (wxWindow *) 0 ;
25208 bool result;
25209 PyObject * obj0 = 0 ;
25210 char *kwnames[] = {
25211 (char *) "self", NULL
25212 };
25213
25214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25216 if (SWIG_arg_fail(1)) SWIG_fail;
25217 {
25218 PyThreadState* __tstate = wxPyBeginAllowThreads();
25219 result = (bool)(arg1)->Destroy();
25220
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 {
25225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25226 }
25227 return resultobj;
25228 fail:
25229 return NULL;
25230 }
25231
25232
25233 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj;
25235 wxWindow *arg1 = (wxWindow *) 0 ;
25236 bool result;
25237 PyObject * obj0 = 0 ;
25238 char *kwnames[] = {
25239 (char *) "self", NULL
25240 };
25241
25242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25244 if (SWIG_arg_fail(1)) SWIG_fail;
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (bool)(arg1)->DestroyChildren();
25248
25249 wxPyEndAllowThreads(__tstate);
25250 if (PyErr_Occurred()) SWIG_fail;
25251 }
25252 {
25253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25254 }
25255 return resultobj;
25256 fail:
25257 return NULL;
25258 }
25259
25260
25261 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25262 PyObject *resultobj;
25263 wxWindow *arg1 = (wxWindow *) 0 ;
25264 bool result;
25265 PyObject * obj0 = 0 ;
25266 char *kwnames[] = {
25267 (char *) "self", NULL
25268 };
25269
25270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25276
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 {
25281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25282 }
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj;
25291 wxWindow *arg1 = (wxWindow *) 0 ;
25292 wxString *arg2 = 0 ;
25293 bool temp2 = false ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self",(char *) "title", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 arg2 = wxString_in_helper(obj1);
25305 if (arg2 == NULL) SWIG_fail;
25306 temp2 = true;
25307 }
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 (arg1)->SetTitle((wxString const &)*arg2);
25311
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 Py_INCREF(Py_None); resultobj = Py_None;
25316 {
25317 if (temp2)
25318 delete arg2;
25319 }
25320 return resultobj;
25321 fail:
25322 {
25323 if (temp2)
25324 delete arg2;
25325 }
25326 return NULL;
25327 }
25328
25329
25330 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25331 PyObject *resultobj;
25332 wxWindow *arg1 = (wxWindow *) 0 ;
25333 wxString result;
25334 PyObject * obj0 = 0 ;
25335 char *kwnames[] = {
25336 (char *) "self", NULL
25337 };
25338
25339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25341 if (SWIG_arg_fail(1)) SWIG_fail;
25342 {
25343 PyThreadState* __tstate = wxPyBeginAllowThreads();
25344 result = ((wxWindow const *)arg1)->GetTitle();
25345
25346 wxPyEndAllowThreads(__tstate);
25347 if (PyErr_Occurred()) SWIG_fail;
25348 }
25349 {
25350 #if wxUSE_UNICODE
25351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25352 #else
25353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25354 #endif
25355 }
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25363 PyObject *resultobj;
25364 wxWindow *arg1 = (wxWindow *) 0 ;
25365 wxString *arg2 = 0 ;
25366 bool temp2 = false ;
25367 PyObject * obj0 = 0 ;
25368 PyObject * obj1 = 0 ;
25369 char *kwnames[] = {
25370 (char *) "self",(char *) "label", NULL
25371 };
25372
25373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25375 if (SWIG_arg_fail(1)) SWIG_fail;
25376 {
25377 arg2 = wxString_in_helper(obj1);
25378 if (arg2 == NULL) SWIG_fail;
25379 temp2 = true;
25380 }
25381 {
25382 PyThreadState* __tstate = wxPyBeginAllowThreads();
25383 (arg1)->SetLabel((wxString const &)*arg2);
25384
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 Py_INCREF(Py_None); resultobj = Py_None;
25389 {
25390 if (temp2)
25391 delete arg2;
25392 }
25393 return resultobj;
25394 fail:
25395 {
25396 if (temp2)
25397 delete arg2;
25398 }
25399 return NULL;
25400 }
25401
25402
25403 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25404 PyObject *resultobj;
25405 wxWindow *arg1 = (wxWindow *) 0 ;
25406 wxString result;
25407 PyObject * obj0 = 0 ;
25408 char *kwnames[] = {
25409 (char *) "self", NULL
25410 };
25411
25412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25414 if (SWIG_arg_fail(1)) SWIG_fail;
25415 {
25416 PyThreadState* __tstate = wxPyBeginAllowThreads();
25417 result = ((wxWindow const *)arg1)->GetLabel();
25418
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 {
25423 #if wxUSE_UNICODE
25424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25425 #else
25426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25427 #endif
25428 }
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj;
25437 wxWindow *arg1 = (wxWindow *) 0 ;
25438 wxString *arg2 = 0 ;
25439 bool temp2 = false ;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 char *kwnames[] = {
25443 (char *) "self",(char *) "name", NULL
25444 };
25445
25446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25448 if (SWIG_arg_fail(1)) SWIG_fail;
25449 {
25450 arg2 = wxString_in_helper(obj1);
25451 if (arg2 == NULL) SWIG_fail;
25452 temp2 = true;
25453 }
25454 {
25455 PyThreadState* __tstate = wxPyBeginAllowThreads();
25456 (arg1)->SetName((wxString const &)*arg2);
25457
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 Py_INCREF(Py_None); resultobj = Py_None;
25462 {
25463 if (temp2)
25464 delete arg2;
25465 }
25466 return resultobj;
25467 fail:
25468 {
25469 if (temp2)
25470 delete arg2;
25471 }
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 wxWindow *arg1 = (wxWindow *) 0 ;
25479 wxString result;
25480 PyObject * obj0 = 0 ;
25481 char *kwnames[] = {
25482 (char *) "self", NULL
25483 };
25484
25485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25487 if (SWIG_arg_fail(1)) SWIG_fail;
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 result = ((wxWindow const *)arg1)->GetName();
25491
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 {
25496 #if wxUSE_UNICODE
25497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25498 #else
25499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25500 #endif
25501 }
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25509 PyObject *resultobj;
25510 wxWindow *arg1 = (wxWindow *) 0 ;
25511 wxWindowVariant arg2 ;
25512 PyObject * obj0 = 0 ;
25513 PyObject * obj1 = 0 ;
25514 char *kwnames[] = {
25515 (char *) "self",(char *) "variant", NULL
25516 };
25517
25518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25520 if (SWIG_arg_fail(1)) SWIG_fail;
25521 {
25522 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25523 if (SWIG_arg_fail(2)) SWIG_fail;
25524 }
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25528
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 Py_INCREF(Py_None); resultobj = Py_None;
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj;
25541 wxWindow *arg1 = (wxWindow *) 0 ;
25542 wxWindowVariant result;
25543 PyObject * obj0 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "self", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25554
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 resultobj = SWIG_From_int((result));
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25566 PyObject *resultobj;
25567 wxWindow *arg1 = (wxWindow *) 0 ;
25568 int arg2 ;
25569 PyObject * obj0 = 0 ;
25570 PyObject * obj1 = 0 ;
25571 char *kwnames[] = {
25572 (char *) "self",(char *) "winid", NULL
25573 };
25574
25575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25577 if (SWIG_arg_fail(1)) SWIG_fail;
25578 {
25579 arg2 = (int)(SWIG_As_int(obj1));
25580 if (SWIG_arg_fail(2)) SWIG_fail;
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 (arg1)->SetId(arg2);
25585
25586 wxPyEndAllowThreads(__tstate);
25587 if (PyErr_Occurred()) SWIG_fail;
25588 }
25589 Py_INCREF(Py_None); resultobj = Py_None;
25590 return resultobj;
25591 fail:
25592 return NULL;
25593 }
25594
25595
25596 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25597 PyObject *resultobj;
25598 wxWindow *arg1 = (wxWindow *) 0 ;
25599 int result;
25600 PyObject * obj0 = 0 ;
25601 char *kwnames[] = {
25602 (char *) "self", NULL
25603 };
25604
25605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25607 if (SWIG_arg_fail(1)) SWIG_fail;
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 result = (int)((wxWindow const *)arg1)->GetId();
25611
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 {
25616 resultobj = SWIG_From_int((int)(result));
25617 }
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj;
25626 int result;
25627 char *kwnames[] = {
25628 NULL
25629 };
25630
25631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 result = (int)wxWindow::NewControlId();
25635
25636 wxPyEndAllowThreads(__tstate);
25637 if (PyErr_Occurred()) SWIG_fail;
25638 }
25639 {
25640 resultobj = SWIG_From_int((int)(result));
25641 }
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25649 PyObject *resultobj;
25650 int arg1 ;
25651 int result;
25652 PyObject * obj0 = 0 ;
25653 char *kwnames[] = {
25654 (char *) "winid", NULL
25655 };
25656
25657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25658 {
25659 arg1 = (int)(SWIG_As_int(obj0));
25660 if (SWIG_arg_fail(1)) SWIG_fail;
25661 }
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (int)wxWindow::NextControlId(arg1);
25665
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 {
25670 resultobj = SWIG_From_int((int)(result));
25671 }
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25679 PyObject *resultobj;
25680 int arg1 ;
25681 int result;
25682 PyObject * obj0 = 0 ;
25683 char *kwnames[] = {
25684 (char *) "winid", NULL
25685 };
25686
25687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25688 {
25689 arg1 = (int)(SWIG_As_int(obj0));
25690 if (SWIG_arg_fail(1)) SWIG_fail;
25691 }
25692 {
25693 PyThreadState* __tstate = wxPyBeginAllowThreads();
25694 result = (int)wxWindow::PrevControlId(arg1);
25695
25696 wxPyEndAllowThreads(__tstate);
25697 if (PyErr_Occurred()) SWIG_fail;
25698 }
25699 {
25700 resultobj = SWIG_From_int((int)(result));
25701 }
25702 return resultobj;
25703 fail:
25704 return NULL;
25705 }
25706
25707
25708 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25709 PyObject *resultobj;
25710 wxWindow *arg1 = (wxWindow *) 0 ;
25711 wxSize *arg2 = 0 ;
25712 wxSize temp2 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 char *kwnames[] = {
25716 (char *) "self",(char *) "size", NULL
25717 };
25718
25719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25721 if (SWIG_arg_fail(1)) SWIG_fail;
25722 {
25723 arg2 = &temp2;
25724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25725 }
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetSize((wxSize const &)*arg2);
25729
25730 wxPyEndAllowThreads(__tstate);
25731 if (PyErr_Occurred()) SWIG_fail;
25732 }
25733 Py_INCREF(Py_None); resultobj = Py_None;
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25741 PyObject *resultobj;
25742 wxWindow *arg1 = (wxWindow *) 0 ;
25743 int arg2 ;
25744 int arg3 ;
25745 int arg4 ;
25746 int arg5 ;
25747 int arg6 = (int) wxSIZE_AUTO ;
25748 PyObject * obj0 = 0 ;
25749 PyObject * obj1 = 0 ;
25750 PyObject * obj2 = 0 ;
25751 PyObject * obj3 = 0 ;
25752 PyObject * obj4 = 0 ;
25753 PyObject * obj5 = 0 ;
25754 char *kwnames[] = {
25755 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25756 };
25757
25758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25760 if (SWIG_arg_fail(1)) SWIG_fail;
25761 {
25762 arg2 = (int)(SWIG_As_int(obj1));
25763 if (SWIG_arg_fail(2)) SWIG_fail;
25764 }
25765 {
25766 arg3 = (int)(SWIG_As_int(obj2));
25767 if (SWIG_arg_fail(3)) SWIG_fail;
25768 }
25769 {
25770 arg4 = (int)(SWIG_As_int(obj3));
25771 if (SWIG_arg_fail(4)) SWIG_fail;
25772 }
25773 {
25774 arg5 = (int)(SWIG_As_int(obj4));
25775 if (SWIG_arg_fail(5)) SWIG_fail;
25776 }
25777 if (obj5) {
25778 {
25779 arg6 = (int)(SWIG_As_int(obj5));
25780 if (SWIG_arg_fail(6)) SWIG_fail;
25781 }
25782 }
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25786
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 Py_INCREF(Py_None); resultobj = Py_None;
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25798 PyObject *resultobj;
25799 wxWindow *arg1 = (wxWindow *) 0 ;
25800 wxRect *arg2 = 0 ;
25801 int arg3 = (int) wxSIZE_AUTO ;
25802 wxRect temp2 ;
25803 PyObject * obj0 = 0 ;
25804 PyObject * obj1 = 0 ;
25805 PyObject * obj2 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 arg2 = &temp2;
25815 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25816 }
25817 if (obj2) {
25818 {
25819 arg3 = (int)(SWIG_As_int(obj2));
25820 if (SWIG_arg_fail(3)) SWIG_fail;
25821 }
25822 }
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25826
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 Py_INCREF(Py_None); resultobj = Py_None;
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25838 PyObject *resultobj;
25839 wxWindow *arg1 = (wxWindow *) 0 ;
25840 int arg2 ;
25841 int arg3 ;
25842 PyObject * obj0 = 0 ;
25843 PyObject * obj1 = 0 ;
25844 PyObject * obj2 = 0 ;
25845 char *kwnames[] = {
25846 (char *) "self",(char *) "width",(char *) "height", NULL
25847 };
25848
25849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25851 if (SWIG_arg_fail(1)) SWIG_fail;
25852 {
25853 arg2 = (int)(SWIG_As_int(obj1));
25854 if (SWIG_arg_fail(2)) SWIG_fail;
25855 }
25856 {
25857 arg3 = (int)(SWIG_As_int(obj2));
25858 if (SWIG_arg_fail(3)) SWIG_fail;
25859 }
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 (arg1)->SetSize(arg2,arg3);
25863
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 Py_INCREF(Py_None); resultobj = Py_None;
25868 return resultobj;
25869 fail:
25870 return NULL;
25871 }
25872
25873
25874 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25875 PyObject *resultobj;
25876 wxWindow *arg1 = (wxWindow *) 0 ;
25877 wxPoint *arg2 = 0 ;
25878 int arg3 = (int) wxSIZE_USE_EXISTING ;
25879 wxPoint temp2 ;
25880 PyObject * obj0 = 0 ;
25881 PyObject * obj1 = 0 ;
25882 PyObject * obj2 = 0 ;
25883 char *kwnames[] = {
25884 (char *) "self",(char *) "pt",(char *) "flags", NULL
25885 };
25886
25887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(1)) SWIG_fail;
25890 {
25891 arg2 = &temp2;
25892 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25893 }
25894 if (obj2) {
25895 {
25896 arg3 = (int)(SWIG_As_int(obj2));
25897 if (SWIG_arg_fail(3)) SWIG_fail;
25898 }
25899 }
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 (arg1)->Move((wxPoint const &)*arg2,arg3);
25903
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 Py_INCREF(Py_None); resultobj = Py_None;
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj;
25916 wxWindow *arg1 = (wxWindow *) 0 ;
25917 int arg2 ;
25918 int arg3 ;
25919 int arg4 = (int) wxSIZE_USE_EXISTING ;
25920 PyObject * obj0 = 0 ;
25921 PyObject * obj1 = 0 ;
25922 PyObject * obj2 = 0 ;
25923 PyObject * obj3 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 {
25932 arg2 = (int)(SWIG_As_int(obj1));
25933 if (SWIG_arg_fail(2)) SWIG_fail;
25934 }
25935 {
25936 arg3 = (int)(SWIG_As_int(obj2));
25937 if (SWIG_arg_fail(3)) SWIG_fail;
25938 }
25939 if (obj3) {
25940 {
25941 arg4 = (int)(SWIG_As_int(obj3));
25942 if (SWIG_arg_fail(4)) SWIG_fail;
25943 }
25944 }
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 (arg1)->Move(arg2,arg3,arg4);
25948
25949 wxPyEndAllowThreads(__tstate);
25950 if (PyErr_Occurred()) SWIG_fail;
25951 }
25952 Py_INCREF(Py_None); resultobj = Py_None;
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25960 PyObject *resultobj;
25961 wxWindow *arg1 = (wxWindow *) 0 ;
25962 wxSize const &arg2_defvalue = wxDefaultSize ;
25963 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25964 wxSize temp2 ;
25965 PyObject * obj0 = 0 ;
25966 PyObject * obj1 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self",(char *) "size", NULL
25969 };
25970
25971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(1)) SWIG_fail;
25974 if (obj1) {
25975 {
25976 arg2 = &temp2;
25977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25978 }
25979 }
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 Py_INCREF(Py_None); resultobj = Py_None;
25988 return resultobj;
25989 fail:
25990 return NULL;
25991 }
25992
25993
25994 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25995 PyObject *resultobj;
25996 wxWindow *arg1 = (wxWindow *) 0 ;
25997 PyObject * obj0 = 0 ;
25998 char *kwnames[] = {
25999 (char *) "self", NULL
26000 };
26001
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(1)) SWIG_fail;
26005 {
26006 PyThreadState* __tstate = wxPyBeginAllowThreads();
26007 (arg1)->Raise();
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 Py_INCREF(Py_None); resultobj = Py_None;
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxWindow *arg1 = (wxWindow *) 0 ;
26022 PyObject * obj0 = 0 ;
26023 char *kwnames[] = {
26024 (char *) "self", NULL
26025 };
26026
26027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26029 if (SWIG_arg_fail(1)) SWIG_fail;
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 (arg1)->Lower();
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 Py_INCREF(Py_None); resultobj = Py_None;
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj;
26046 wxWindow *arg1 = (wxWindow *) 0 ;
26047 wxSize *arg2 = 0 ;
26048 wxSize temp2 ;
26049 PyObject * obj0 = 0 ;
26050 PyObject * obj1 = 0 ;
26051 char *kwnames[] = {
26052 (char *) "self",(char *) "size", NULL
26053 };
26054
26055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26057 if (SWIG_arg_fail(1)) SWIG_fail;
26058 {
26059 arg2 = &temp2;
26060 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26061 }
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 (arg1)->SetClientSize((wxSize const &)*arg2);
26065
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 Py_INCREF(Py_None); resultobj = Py_None;
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26077 PyObject *resultobj;
26078 wxWindow *arg1 = (wxWindow *) 0 ;
26079 int arg2 ;
26080 int arg3 ;
26081 PyObject * obj0 = 0 ;
26082 PyObject * obj1 = 0 ;
26083 PyObject * obj2 = 0 ;
26084 char *kwnames[] = {
26085 (char *) "self",(char *) "width",(char *) "height", NULL
26086 };
26087
26088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26090 if (SWIG_arg_fail(1)) SWIG_fail;
26091 {
26092 arg2 = (int)(SWIG_As_int(obj1));
26093 if (SWIG_arg_fail(2)) SWIG_fail;
26094 }
26095 {
26096 arg3 = (int)(SWIG_As_int(obj2));
26097 if (SWIG_arg_fail(3)) SWIG_fail;
26098 }
26099 {
26100 PyThreadState* __tstate = wxPyBeginAllowThreads();
26101 (arg1)->SetClientSize(arg2,arg3);
26102
26103 wxPyEndAllowThreads(__tstate);
26104 if (PyErr_Occurred()) SWIG_fail;
26105 }
26106 Py_INCREF(Py_None); resultobj = Py_None;
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj;
26115 wxWindow *arg1 = (wxWindow *) 0 ;
26116 wxRect *arg2 = 0 ;
26117 wxRect temp2 ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char *kwnames[] = {
26121 (char *) "self",(char *) "rect", NULL
26122 };
26123
26124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(1)) SWIG_fail;
26127 {
26128 arg2 = &temp2;
26129 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26130 }
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 (arg1)->SetClientSize((wxRect const &)*arg2);
26134
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 Py_INCREF(Py_None); resultobj = Py_None;
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj;
26147 wxWindow *arg1 = (wxWindow *) 0 ;
26148 wxPoint result;
26149 PyObject * obj0 = 0 ;
26150 char *kwnames[] = {
26151 (char *) "self", NULL
26152 };
26153
26154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26156 if (SWIG_arg_fail(1)) SWIG_fail;
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 result = (arg1)->GetPosition();
26160
26161 wxPyEndAllowThreads(__tstate);
26162 if (PyErr_Occurred()) SWIG_fail;
26163 }
26164 {
26165 wxPoint * resultptr;
26166 resultptr = new wxPoint((wxPoint &)(result));
26167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26168 }
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26176 PyObject *resultobj;
26177 wxWindow *arg1 = (wxWindow *) 0 ;
26178 int *arg2 = (int *) 0 ;
26179 int *arg3 = (int *) 0 ;
26180 int temp2 ;
26181 int res2 = 0 ;
26182 int temp3 ;
26183 int res3 = 0 ;
26184 PyObject * obj0 = 0 ;
26185 char *kwnames[] = {
26186 (char *) "self", NULL
26187 };
26188
26189 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26190 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26193 if (SWIG_arg_fail(1)) SWIG_fail;
26194 {
26195 PyThreadState* __tstate = wxPyBeginAllowThreads();
26196 (arg1)->GetPosition(arg2,arg3);
26197
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 Py_INCREF(Py_None); resultobj = Py_None;
26202 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26203 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26204 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26205 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26213 PyObject *resultobj;
26214 wxWindow *arg1 = (wxWindow *) 0 ;
26215 wxSize result;
26216 PyObject * obj0 = 0 ;
26217 char *kwnames[] = {
26218 (char *) "self", NULL
26219 };
26220
26221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26223 if (SWIG_arg_fail(1)) SWIG_fail;
26224 {
26225 PyThreadState* __tstate = wxPyBeginAllowThreads();
26226 result = ((wxWindow const *)arg1)->GetSize();
26227
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 {
26232 wxSize * resultptr;
26233 resultptr = new wxSize((wxSize &)(result));
26234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26235 }
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj;
26244 wxWindow *arg1 = (wxWindow *) 0 ;
26245 int *arg2 = (int *) 0 ;
26246 int *arg3 = (int *) 0 ;
26247 int temp2 ;
26248 int res2 = 0 ;
26249 int temp3 ;
26250 int res3 = 0 ;
26251 PyObject * obj0 = 0 ;
26252 char *kwnames[] = {
26253 (char *) "self", NULL
26254 };
26255
26256 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26257 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26260 if (SWIG_arg_fail(1)) SWIG_fail;
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26264
26265 wxPyEndAllowThreads(__tstate);
26266 if (PyErr_Occurred()) SWIG_fail;
26267 }
26268 Py_INCREF(Py_None); resultobj = Py_None;
26269 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26270 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26271 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26272 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj;
26281 wxWindow *arg1 = (wxWindow *) 0 ;
26282 wxRect result;
26283 PyObject * obj0 = 0 ;
26284 char *kwnames[] = {
26285 (char *) "self", NULL
26286 };
26287
26288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26290 if (SWIG_arg_fail(1)) SWIG_fail;
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 result = ((wxWindow const *)arg1)->GetRect();
26294
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 {
26299 wxRect * resultptr;
26300 resultptr = new wxRect((wxRect &)(result));
26301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26302 }
26303 return resultobj;
26304 fail:
26305 return NULL;
26306 }
26307
26308
26309 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26310 PyObject *resultobj;
26311 wxWindow *arg1 = (wxWindow *) 0 ;
26312 wxSize result;
26313 PyObject * obj0 = 0 ;
26314 char *kwnames[] = {
26315 (char *) "self", NULL
26316 };
26317
26318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26320 if (SWIG_arg_fail(1)) SWIG_fail;
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = ((wxWindow const *)arg1)->GetClientSize();
26324
26325 wxPyEndAllowThreads(__tstate);
26326 if (PyErr_Occurred()) SWIG_fail;
26327 }
26328 {
26329 wxSize * resultptr;
26330 resultptr = new wxSize((wxSize &)(result));
26331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26332 }
26333 return resultobj;
26334 fail:
26335 return NULL;
26336 }
26337
26338
26339 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26340 PyObject *resultobj;
26341 wxWindow *arg1 = (wxWindow *) 0 ;
26342 int *arg2 = (int *) 0 ;
26343 int *arg3 = (int *) 0 ;
26344 int temp2 ;
26345 int res2 = 0 ;
26346 int temp3 ;
26347 int res3 = 0 ;
26348 PyObject * obj0 = 0 ;
26349 char *kwnames[] = {
26350 (char *) "self", NULL
26351 };
26352
26353 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26354 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26357 if (SWIG_arg_fail(1)) SWIG_fail;
26358 {
26359 PyThreadState* __tstate = wxPyBeginAllowThreads();
26360 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26361
26362 wxPyEndAllowThreads(__tstate);
26363 if (PyErr_Occurred()) SWIG_fail;
26364 }
26365 Py_INCREF(Py_None); resultobj = Py_None;
26366 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26367 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26368 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26369 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26370 return resultobj;
26371 fail:
26372 return NULL;
26373 }
26374
26375
26376 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26377 PyObject *resultobj;
26378 wxWindow *arg1 = (wxWindow *) 0 ;
26379 wxPoint result;
26380 PyObject * obj0 = 0 ;
26381 char *kwnames[] = {
26382 (char *) "self", NULL
26383 };
26384
26385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26387 if (SWIG_arg_fail(1)) SWIG_fail;
26388 {
26389 PyThreadState* __tstate = wxPyBeginAllowThreads();
26390 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26391
26392 wxPyEndAllowThreads(__tstate);
26393 if (PyErr_Occurred()) SWIG_fail;
26394 }
26395 {
26396 wxPoint * resultptr;
26397 resultptr = new wxPoint((wxPoint &)(result));
26398 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26399 }
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj;
26408 wxWindow *arg1 = (wxWindow *) 0 ;
26409 wxRect result;
26410 PyObject * obj0 = 0 ;
26411 char *kwnames[] = {
26412 (char *) "self", NULL
26413 };
26414
26415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26417 if (SWIG_arg_fail(1)) SWIG_fail;
26418 {
26419 PyThreadState* __tstate = wxPyBeginAllowThreads();
26420 result = ((wxWindow const *)arg1)->GetClientRect();
26421
26422 wxPyEndAllowThreads(__tstate);
26423 if (PyErr_Occurred()) SWIG_fail;
26424 }
26425 {
26426 wxRect * resultptr;
26427 resultptr = new wxRect((wxRect &)(result));
26428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26429 }
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj;
26438 wxWindow *arg1 = (wxWindow *) 0 ;
26439 wxSize result;
26440 PyObject * obj0 = 0 ;
26441 char *kwnames[] = {
26442 (char *) "self", NULL
26443 };
26444
26445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26447 if (SWIG_arg_fail(1)) SWIG_fail;
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = ((wxWindow const *)arg1)->GetBestSize();
26451
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 {
26456 wxSize * resultptr;
26457 resultptr = new wxSize((wxSize &)(result));
26458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26459 }
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26467 PyObject *resultobj;
26468 wxWindow *arg1 = (wxWindow *) 0 ;
26469 int *arg2 = (int *) 0 ;
26470 int *arg3 = (int *) 0 ;
26471 int temp2 ;
26472 int res2 = 0 ;
26473 int temp3 ;
26474 int res3 = 0 ;
26475 PyObject * obj0 = 0 ;
26476 char *kwnames[] = {
26477 (char *) "self", NULL
26478 };
26479
26480 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26481 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26484 if (SWIG_arg_fail(1)) SWIG_fail;
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 Py_INCREF(Py_None); resultobj = Py_None;
26493 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26494 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26495 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26496 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26504 PyObject *resultobj;
26505 wxWindow *arg1 = (wxWindow *) 0 ;
26506 PyObject * obj0 = 0 ;
26507 char *kwnames[] = {
26508 (char *) "self", NULL
26509 };
26510
26511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26513 if (SWIG_arg_fail(1)) SWIG_fail;
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 (arg1)->InvalidateBestSize();
26517
26518 wxPyEndAllowThreads(__tstate);
26519 if (PyErr_Occurred()) SWIG_fail;
26520 }
26521 Py_INCREF(Py_None); resultobj = Py_None;
26522 return resultobj;
26523 fail:
26524 return NULL;
26525 }
26526
26527
26528 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26529 PyObject *resultobj;
26530 wxWindow *arg1 = (wxWindow *) 0 ;
26531 wxSize result;
26532 PyObject * obj0 = 0 ;
26533 char *kwnames[] = {
26534 (char *) "self", NULL
26535 };
26536
26537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26539 if (SWIG_arg_fail(1)) SWIG_fail;
26540 {
26541 PyThreadState* __tstate = wxPyBeginAllowThreads();
26542 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26543
26544 wxPyEndAllowThreads(__tstate);
26545 if (PyErr_Occurred()) SWIG_fail;
26546 }
26547 {
26548 wxSize * resultptr;
26549 resultptr = new wxSize((wxSize &)(result));
26550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26551 }
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26559 PyObject *resultobj;
26560 wxWindow *arg1 = (wxWindow *) 0 ;
26561 wxSize result;
26562 PyObject * obj0 = 0 ;
26563 char *kwnames[] = {
26564 (char *) "self", NULL
26565 };
26566
26567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 {
26571 PyThreadState* __tstate = wxPyBeginAllowThreads();
26572 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26573
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 {
26578 wxSize * resultptr;
26579 resultptr = new wxSize((wxSize &)(result));
26580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26581 }
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj;
26590 wxWindow *arg1 = (wxWindow *) 0 ;
26591 int arg2 = (int) wxBOTH ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 char *kwnames[] = {
26595 (char *) "self",(char *) "direction", NULL
26596 };
26597
26598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26600 if (SWIG_arg_fail(1)) SWIG_fail;
26601 if (obj1) {
26602 {
26603 arg2 = (int)(SWIG_As_int(obj1));
26604 if (SWIG_arg_fail(2)) SWIG_fail;
26605 }
26606 }
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 (arg1)->Center(arg2);
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 Py_INCREF(Py_None); resultobj = Py_None;
26615 return resultobj;
26616 fail:
26617 return NULL;
26618 }
26619
26620
26621 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj;
26623 wxWindow *arg1 = (wxWindow *) 0 ;
26624 int arg2 = (int) wxBOTH ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char *kwnames[] = {
26628 (char *) "self",(char *) "dir", NULL
26629 };
26630
26631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26633 if (SWIG_arg_fail(1)) SWIG_fail;
26634 if (obj1) {
26635 {
26636 arg2 = (int)(SWIG_As_int(obj1));
26637 if (SWIG_arg_fail(2)) SWIG_fail;
26638 }
26639 }
26640 {
26641 PyThreadState* __tstate = wxPyBeginAllowThreads();
26642 (arg1)->CenterOnScreen(arg2);
26643
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 Py_INCREF(Py_None); resultobj = Py_None;
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26655 PyObject *resultobj;
26656 wxWindow *arg1 = (wxWindow *) 0 ;
26657 int arg2 = (int) wxBOTH ;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 char *kwnames[] = {
26661 (char *) "self",(char *) "dir", NULL
26662 };
26663
26664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26666 if (SWIG_arg_fail(1)) SWIG_fail;
26667 if (obj1) {
26668 {
26669 arg2 = (int)(SWIG_As_int(obj1));
26670 if (SWIG_arg_fail(2)) SWIG_fail;
26671 }
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 (arg1)->CenterOnParent(arg2);
26676
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 Py_INCREF(Py_None); resultobj = Py_None;
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26688 PyObject *resultobj;
26689 wxWindow *arg1 = (wxWindow *) 0 ;
26690 PyObject * obj0 = 0 ;
26691 char *kwnames[] = {
26692 (char *) "self", NULL
26693 };
26694
26695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26697 if (SWIG_arg_fail(1)) SWIG_fail;
26698 {
26699 PyThreadState* __tstate = wxPyBeginAllowThreads();
26700 (arg1)->Fit();
26701
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 Py_INCREF(Py_None); resultobj = Py_None;
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj;
26714 wxWindow *arg1 = (wxWindow *) 0 ;
26715 PyObject * obj0 = 0 ;
26716 char *kwnames[] = {
26717 (char *) "self", NULL
26718 };
26719
26720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26722 if (SWIG_arg_fail(1)) SWIG_fail;
26723 {
26724 PyThreadState* __tstate = wxPyBeginAllowThreads();
26725 (arg1)->FitInside();
26726
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 Py_INCREF(Py_None); resultobj = Py_None;
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26738 PyObject *resultobj;
26739 wxWindow *arg1 = (wxWindow *) 0 ;
26740 int arg2 ;
26741 int arg3 ;
26742 int arg4 = (int) -1 ;
26743 int arg5 = (int) -1 ;
26744 int arg6 = (int) -1 ;
26745 int arg7 = (int) -1 ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 PyObject * obj2 = 0 ;
26749 PyObject * obj3 = 0 ;
26750 PyObject * obj4 = 0 ;
26751 PyObject * obj5 = 0 ;
26752 PyObject * obj6 = 0 ;
26753 char *kwnames[] = {
26754 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26755 };
26756
26757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(1)) SWIG_fail;
26760 {
26761 arg2 = (int)(SWIG_As_int(obj1));
26762 if (SWIG_arg_fail(2)) SWIG_fail;
26763 }
26764 {
26765 arg3 = (int)(SWIG_As_int(obj2));
26766 if (SWIG_arg_fail(3)) SWIG_fail;
26767 }
26768 if (obj3) {
26769 {
26770 arg4 = (int)(SWIG_As_int(obj3));
26771 if (SWIG_arg_fail(4)) SWIG_fail;
26772 }
26773 }
26774 if (obj4) {
26775 {
26776 arg5 = (int)(SWIG_As_int(obj4));
26777 if (SWIG_arg_fail(5)) SWIG_fail;
26778 }
26779 }
26780 if (obj5) {
26781 {
26782 arg6 = (int)(SWIG_As_int(obj5));
26783 if (SWIG_arg_fail(6)) SWIG_fail;
26784 }
26785 }
26786 if (obj6) {
26787 {
26788 arg7 = (int)(SWIG_As_int(obj6));
26789 if (SWIG_arg_fail(7)) SWIG_fail;
26790 }
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 Py_INCREF(Py_None); resultobj = Py_None;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxWindow *arg1 = (wxWindow *) 0 ;
26809 wxSize *arg2 = 0 ;
26810 wxSize const &arg3_defvalue = wxDefaultSize ;
26811 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26812 wxSize const &arg4_defvalue = wxDefaultSize ;
26813 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26814 wxSize temp2 ;
26815 wxSize temp3 ;
26816 wxSize temp4 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 PyObject * obj2 = 0 ;
26820 PyObject * obj3 = 0 ;
26821 char *kwnames[] = {
26822 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26823 };
26824
26825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26827 if (SWIG_arg_fail(1)) SWIG_fail;
26828 {
26829 arg2 = &temp2;
26830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26831 }
26832 if (obj2) {
26833 {
26834 arg3 = &temp3;
26835 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26836 }
26837 }
26838 if (obj3) {
26839 {
26840 arg4 = &temp4;
26841 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26842 }
26843 }
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26847
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 Py_INCREF(Py_None); resultobj = Py_None;
26852 return resultobj;
26853 fail:
26854 return NULL;
26855 }
26856
26857
26858 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26859 PyObject *resultobj;
26860 wxWindow *arg1 = (wxWindow *) 0 ;
26861 int arg2 ;
26862 int arg3 ;
26863 int arg4 = (int) -1 ;
26864 int arg5 = (int) -1 ;
26865 PyObject * obj0 = 0 ;
26866 PyObject * obj1 = 0 ;
26867 PyObject * obj2 = 0 ;
26868 PyObject * obj3 = 0 ;
26869 PyObject * obj4 = 0 ;
26870 char *kwnames[] = {
26871 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26872 };
26873
26874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26876 if (SWIG_arg_fail(1)) SWIG_fail;
26877 {
26878 arg2 = (int)(SWIG_As_int(obj1));
26879 if (SWIG_arg_fail(2)) SWIG_fail;
26880 }
26881 {
26882 arg3 = (int)(SWIG_As_int(obj2));
26883 if (SWIG_arg_fail(3)) SWIG_fail;
26884 }
26885 if (obj3) {
26886 {
26887 arg4 = (int)(SWIG_As_int(obj3));
26888 if (SWIG_arg_fail(4)) SWIG_fail;
26889 }
26890 }
26891 if (obj4) {
26892 {
26893 arg5 = (int)(SWIG_As_int(obj4));
26894 if (SWIG_arg_fail(5)) SWIG_fail;
26895 }
26896 }
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26900
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 Py_INCREF(Py_None); resultobj = Py_None;
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 wxSize *arg2 = 0 ;
26915 wxSize const &arg3_defvalue = wxDefaultSize ;
26916 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26917 wxSize temp2 ;
26918 wxSize temp3 ;
26919 PyObject * obj0 = 0 ;
26920 PyObject * obj1 = 0 ;
26921 PyObject * obj2 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 arg2 = &temp2;
26931 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26932 }
26933 if (obj2) {
26934 {
26935 arg3 = &temp3;
26936 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26937 }
26938 }
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 Py_INCREF(Py_None); resultobj = Py_None;
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxWindow *arg1 = (wxWindow *) 0 ;
26956 wxSize result;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = ((wxWindow const *)arg1)->GetMaxSize();
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 wxSize * resultptr;
26974 resultptr = new wxSize((wxSize &)(result));
26975 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26976 }
26977 return resultobj;
26978 fail:
26979 return NULL;
26980 }
26981
26982
26983 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj;
26985 wxWindow *arg1 = (wxWindow *) 0 ;
26986 wxSize result;
26987 PyObject * obj0 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 {
26996 PyThreadState* __tstate = wxPyBeginAllowThreads();
26997 result = ((wxWindow const *)arg1)->GetMinSize();
26998
26999 wxPyEndAllowThreads(__tstate);
27000 if (PyErr_Occurred()) SWIG_fail;
27001 }
27002 {
27003 wxSize * resultptr;
27004 resultptr = new wxSize((wxSize &)(result));
27005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27006 }
27007 return resultobj;
27008 fail:
27009 return NULL;
27010 }
27011
27012
27013 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27014 PyObject *resultobj;
27015 wxWindow *arg1 = (wxWindow *) 0 ;
27016 wxSize *arg2 = 0 ;
27017 wxSize temp2 ;
27018 PyObject * obj0 = 0 ;
27019 PyObject * obj1 = 0 ;
27020 char *kwnames[] = {
27021 (char *) "self",(char *) "minSize", NULL
27022 };
27023
27024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
27029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27030 }
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 (arg1)->SetMinSize((wxSize const &)*arg2);
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 Py_INCREF(Py_None); resultobj = Py_None;
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxWindow *arg1 = (wxWindow *) 0 ;
27048 wxSize *arg2 = 0 ;
27049 wxSize temp2 ;
27050 PyObject * obj0 = 0 ;
27051 PyObject * obj1 = 0 ;
27052 char *kwnames[] = {
27053 (char *) "self",(char *) "maxSize", NULL
27054 };
27055
27056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27058 if (SWIG_arg_fail(1)) SWIG_fail;
27059 {
27060 arg2 = &temp2;
27061 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27062 }
27063 {
27064 PyThreadState* __tstate = wxPyBeginAllowThreads();
27065 (arg1)->SetMaxSize((wxSize const &)*arg2);
27066
27067 wxPyEndAllowThreads(__tstate);
27068 if (PyErr_Occurred()) SWIG_fail;
27069 }
27070 Py_INCREF(Py_None); resultobj = Py_None;
27071 return resultobj;
27072 fail:
27073 return NULL;
27074 }
27075
27076
27077 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27078 PyObject *resultobj;
27079 wxWindow *arg1 = (wxWindow *) 0 ;
27080 int result;
27081 PyObject * obj0 = 0 ;
27082 char *kwnames[] = {
27083 (char *) "self", NULL
27084 };
27085
27086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27088 if (SWIG_arg_fail(1)) SWIG_fail;
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27092
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 {
27097 resultobj = SWIG_From_int((int)(result));
27098 }
27099 return resultobj;
27100 fail:
27101 return NULL;
27102 }
27103
27104
27105 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27106 PyObject *resultobj;
27107 wxWindow *arg1 = (wxWindow *) 0 ;
27108 int result;
27109 PyObject * obj0 = 0 ;
27110 char *kwnames[] = {
27111 (char *) "self", NULL
27112 };
27113
27114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27116 if (SWIG_arg_fail(1)) SWIG_fail;
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27120
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = SWIG_From_int((int)(result));
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27134 PyObject *resultobj;
27135 wxWindow *arg1 = (wxWindow *) 0 ;
27136 int result;
27137 PyObject * obj0 = 0 ;
27138 char *kwnames[] = {
27139 (char *) "self", NULL
27140 };
27141
27142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27144 if (SWIG_arg_fail(1)) SWIG_fail;
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27148
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 {
27153 resultobj = SWIG_From_int((int)(result));
27154 }
27155 return resultobj;
27156 fail:
27157 return NULL;
27158 }
27159
27160
27161 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27162 PyObject *resultobj;
27163 wxWindow *arg1 = (wxWindow *) 0 ;
27164 int result;
27165 PyObject * obj0 = 0 ;
27166 char *kwnames[] = {
27167 (char *) "self", NULL
27168 };
27169
27170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27172 if (SWIG_arg_fail(1)) SWIG_fail;
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27176
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 {
27181 resultobj = SWIG_From_int((int)(result));
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj;
27191 wxWindow *arg1 = (wxWindow *) 0 ;
27192 wxSize *arg2 = 0 ;
27193 wxSize temp2 ;
27194 PyObject * obj0 = 0 ;
27195 PyObject * obj1 = 0 ;
27196 char *kwnames[] = {
27197 (char *) "self",(char *) "size", NULL
27198 };
27199
27200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27202 if (SWIG_arg_fail(1)) SWIG_fail;
27203 {
27204 arg2 = &temp2;
27205 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27206 }
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27210
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 Py_INCREF(Py_None); resultobj = Py_None;
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27222 PyObject *resultobj;
27223 wxWindow *arg1 = (wxWindow *) 0 ;
27224 int arg2 ;
27225 int arg3 ;
27226 PyObject * obj0 = 0 ;
27227 PyObject * obj1 = 0 ;
27228 PyObject * obj2 = 0 ;
27229 char *kwnames[] = {
27230 (char *) "self",(char *) "w",(char *) "h", NULL
27231 };
27232
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) 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 {
27237 arg2 = (int)(SWIG_As_int(obj1));
27238 if (SWIG_arg_fail(2)) SWIG_fail;
27239 }
27240 {
27241 arg3 = (int)(SWIG_As_int(obj2));
27242 if (SWIG_arg_fail(3)) SWIG_fail;
27243 }
27244 {
27245 PyThreadState* __tstate = wxPyBeginAllowThreads();
27246 (arg1)->SetVirtualSize(arg2,arg3);
27247
27248 wxPyEndAllowThreads(__tstate);
27249 if (PyErr_Occurred()) SWIG_fail;
27250 }
27251 Py_INCREF(Py_None); resultobj = Py_None;
27252 return resultobj;
27253 fail:
27254 return NULL;
27255 }
27256
27257
27258 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27259 PyObject *resultobj;
27260 wxWindow *arg1 = (wxWindow *) 0 ;
27261 wxSize result;
27262 PyObject * obj0 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = ((wxWindow const *)arg1)->GetVirtualSize();
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 {
27278 wxSize * resultptr;
27279 resultptr = new wxSize((wxSize &)(result));
27280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27281 }
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj;
27290 wxWindow *arg1 = (wxWindow *) 0 ;
27291 int *arg2 = (int *) 0 ;
27292 int *arg3 = (int *) 0 ;
27293 int temp2 ;
27294 int res2 = 0 ;
27295 int temp3 ;
27296 int res3 = 0 ;
27297 PyObject * obj0 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self", NULL
27300 };
27301
27302 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27303 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27310
27311 wxPyEndAllowThreads(__tstate);
27312 if (PyErr_Occurred()) SWIG_fail;
27313 }
27314 Py_INCREF(Py_None); resultobj = Py_None;
27315 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27316 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27317 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27318 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27326 PyObject *resultobj;
27327 wxWindow *arg1 = (wxWindow *) 0 ;
27328 wxSize result;
27329 PyObject * obj0 = 0 ;
27330 char *kwnames[] = {
27331 (char *) "self", NULL
27332 };
27333
27334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(1)) SWIG_fail;
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27340
27341 wxPyEndAllowThreads(__tstate);
27342 if (PyErr_Occurred()) SWIG_fail;
27343 }
27344 {
27345 wxSize * resultptr;
27346 resultptr = new wxSize((wxSize &)(result));
27347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27348 }
27349 return resultobj;
27350 fail:
27351 return NULL;
27352 }
27353
27354
27355 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27356 PyObject *resultobj;
27357 wxWindow *arg1 = (wxWindow *) 0 ;
27358 bool arg2 = (bool) true ;
27359 bool result;
27360 PyObject * obj0 = 0 ;
27361 PyObject * obj1 = 0 ;
27362 char *kwnames[] = {
27363 (char *) "self",(char *) "show", NULL
27364 };
27365
27366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27368 if (SWIG_arg_fail(1)) SWIG_fail;
27369 if (obj1) {
27370 {
27371 arg2 = (bool)(SWIG_As_bool(obj1));
27372 if (SWIG_arg_fail(2)) SWIG_fail;
27373 }
27374 }
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (bool)(arg1)->Show(arg2);
27378
27379 wxPyEndAllowThreads(__tstate);
27380 if (PyErr_Occurred()) SWIG_fail;
27381 }
27382 {
27383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27384 }
27385 return resultobj;
27386 fail:
27387 return NULL;
27388 }
27389
27390
27391 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27392 PyObject *resultobj;
27393 wxWindow *arg1 = (wxWindow *) 0 ;
27394 bool result;
27395 PyObject * obj0 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "self", NULL
27398 };
27399
27400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27402 if (SWIG_arg_fail(1)) SWIG_fail;
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 result = (bool)(arg1)->Hide();
27406
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 {
27411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27412 }
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27420 PyObject *resultobj;
27421 wxWindow *arg1 = (wxWindow *) 0 ;
27422 bool arg2 = (bool) true ;
27423 bool result;
27424 PyObject * obj0 = 0 ;
27425 PyObject * obj1 = 0 ;
27426 char *kwnames[] = {
27427 (char *) "self",(char *) "enable", NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(1)) SWIG_fail;
27433 if (obj1) {
27434 {
27435 arg2 = (bool)(SWIG_As_bool(obj1));
27436 if (SWIG_arg_fail(2)) SWIG_fail;
27437 }
27438 }
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = (bool)(arg1)->Enable(arg2);
27442
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 {
27447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27448 }
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27456 PyObject *resultobj;
27457 wxWindow *arg1 = (wxWindow *) 0 ;
27458 bool result;
27459 PyObject * obj0 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "self", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = (bool)(arg1)->Disable();
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 {
27475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27476 }
27477 return resultobj;
27478 fail:
27479 return NULL;
27480 }
27481
27482
27483 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxWindow *arg1 = (wxWindow *) 0 ;
27486 bool result;
27487 PyObject * obj0 = 0 ;
27488 char *kwnames[] = {
27489 (char *) "self", NULL
27490 };
27491
27492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27494 if (SWIG_arg_fail(1)) SWIG_fail;
27495 {
27496 PyThreadState* __tstate = wxPyBeginAllowThreads();
27497 result = (bool)((wxWindow const *)arg1)->IsShown();
27498
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 {
27503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj;
27513 wxWindow *arg1 = (wxWindow *) 0 ;
27514 bool result;
27515 PyObject * obj0 = 0 ;
27516 char *kwnames[] = {
27517 (char *) "self", NULL
27518 };
27519
27520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27522 if (SWIG_arg_fail(1)) SWIG_fail;
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27526
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 {
27531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27532 }
27533 return resultobj;
27534 fail:
27535 return NULL;
27536 }
27537
27538
27539 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27540 PyObject *resultobj;
27541 wxWindow *arg1 = (wxWindow *) 0 ;
27542 long arg2 ;
27543 PyObject * obj0 = 0 ;
27544 PyObject * obj1 = 0 ;
27545 char *kwnames[] = {
27546 (char *) "self",(char *) "style", NULL
27547 };
27548
27549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27551 if (SWIG_arg_fail(1)) SWIG_fail;
27552 {
27553 arg2 = (long)(SWIG_As_long(obj1));
27554 if (SWIG_arg_fail(2)) SWIG_fail;
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 (arg1)->SetWindowStyleFlag(arg2);
27559
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 Py_INCREF(Py_None); resultobj = Py_None;
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27571 PyObject *resultobj;
27572 wxWindow *arg1 = (wxWindow *) 0 ;
27573 long result;
27574 PyObject * obj0 = 0 ;
27575 char *kwnames[] = {
27576 (char *) "self", NULL
27577 };
27578
27579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27581 if (SWIG_arg_fail(1)) SWIG_fail;
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27585
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 {
27590 resultobj = SWIG_From_long((long)(result));
27591 }
27592 return resultobj;
27593 fail:
27594 return NULL;
27595 }
27596
27597
27598 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27599 PyObject *resultobj;
27600 wxWindow *arg1 = (wxWindow *) 0 ;
27601 int arg2 ;
27602 bool result;
27603 PyObject * obj0 = 0 ;
27604 PyObject * obj1 = 0 ;
27605 char *kwnames[] = {
27606 (char *) "self",(char *) "flag", NULL
27607 };
27608
27609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27611 if (SWIG_arg_fail(1)) SWIG_fail;
27612 {
27613 arg2 = (int)(SWIG_As_int(obj1));
27614 if (SWIG_arg_fail(2)) SWIG_fail;
27615 }
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27633 PyObject *resultobj;
27634 wxWindow *arg1 = (wxWindow *) 0 ;
27635 bool result;
27636 PyObject * obj0 = 0 ;
27637 char *kwnames[] = {
27638 (char *) "self", NULL
27639 };
27640
27641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (bool)((wxWindow const *)arg1)->IsRetained();
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 {
27652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27653 }
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27661 PyObject *resultobj;
27662 wxWindow *arg1 = (wxWindow *) 0 ;
27663 long arg2 ;
27664 PyObject * obj0 = 0 ;
27665 PyObject * obj1 = 0 ;
27666 char *kwnames[] = {
27667 (char *) "self",(char *) "exStyle", NULL
27668 };
27669
27670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27672 if (SWIG_arg_fail(1)) SWIG_fail;
27673 {
27674 arg2 = (long)(SWIG_As_long(obj1));
27675 if (SWIG_arg_fail(2)) SWIG_fail;
27676 }
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 (arg1)->SetExtraStyle(arg2);
27680
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 Py_INCREF(Py_None); resultobj = Py_None;
27685 return resultobj;
27686 fail:
27687 return NULL;
27688 }
27689
27690
27691 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27692 PyObject *resultobj;
27693 wxWindow *arg1 = (wxWindow *) 0 ;
27694 long result;
27695 PyObject * obj0 = 0 ;
27696 char *kwnames[] = {
27697 (char *) "self", NULL
27698 };
27699
27700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27702 if (SWIG_arg_fail(1)) SWIG_fail;
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27706
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 {
27711 resultobj = SWIG_From_long((long)(result));
27712 }
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27720 PyObject *resultobj;
27721 wxWindow *arg1 = (wxWindow *) 0 ;
27722 bool arg2 = (bool) true ;
27723 PyObject * obj0 = 0 ;
27724 PyObject * obj1 = 0 ;
27725 char *kwnames[] = {
27726 (char *) "self",(char *) "modal", NULL
27727 };
27728
27729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27731 if (SWIG_arg_fail(1)) SWIG_fail;
27732 if (obj1) {
27733 {
27734 arg2 = (bool)(SWIG_As_bool(obj1));
27735 if (SWIG_arg_fail(2)) SWIG_fail;
27736 }
27737 }
27738 {
27739 PyThreadState* __tstate = wxPyBeginAllowThreads();
27740 (arg1)->MakeModal(arg2);
27741
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 Py_INCREF(Py_None); resultobj = Py_None;
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj;
27754 wxWindow *arg1 = (wxWindow *) 0 ;
27755 bool arg2 ;
27756 PyObject * obj0 = 0 ;
27757 PyObject * obj1 = 0 ;
27758 char *kwnames[] = {
27759 (char *) "self",(char *) "enableTheme", NULL
27760 };
27761
27762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 {
27766 arg2 = (bool)(SWIG_As_bool(obj1));
27767 if (SWIG_arg_fail(2)) SWIG_fail;
27768 }
27769 {
27770 PyThreadState* __tstate = wxPyBeginAllowThreads();
27771 (arg1)->SetThemeEnabled(arg2);
27772
27773 wxPyEndAllowThreads(__tstate);
27774 if (PyErr_Occurred()) SWIG_fail;
27775 }
27776 Py_INCREF(Py_None); resultobj = Py_None;
27777 return resultobj;
27778 fail:
27779 return NULL;
27780 }
27781
27782
27783 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27784 PyObject *resultobj;
27785 wxWindow *arg1 = (wxWindow *) 0 ;
27786 bool result;
27787 PyObject * obj0 = 0 ;
27788 char *kwnames[] = {
27789 (char *) "self", NULL
27790 };
27791
27792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27794 if (SWIG_arg_fail(1)) SWIG_fail;
27795 {
27796 PyThreadState* __tstate = wxPyBeginAllowThreads();
27797 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27798
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 {
27803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27804 }
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj;
27813 wxWindow *arg1 = (wxWindow *) 0 ;
27814 PyObject * obj0 = 0 ;
27815 char *kwnames[] = {
27816 (char *) "self", NULL
27817 };
27818
27819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27821 if (SWIG_arg_fail(1)) SWIG_fail;
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 (arg1)->SetFocus();
27825
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 Py_INCREF(Py_None); resultobj = Py_None;
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27837 PyObject *resultobj;
27838 wxWindow *arg1 = (wxWindow *) 0 ;
27839 PyObject * obj0 = 0 ;
27840 char *kwnames[] = {
27841 (char *) "self", NULL
27842 };
27843
27844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27846 if (SWIG_arg_fail(1)) SWIG_fail;
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 (arg1)->SetFocusFromKbd();
27850
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 Py_INCREF(Py_None); resultobj = Py_None;
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj;
27863 wxWindow *result;
27864 char *kwnames[] = {
27865 NULL
27866 };
27867
27868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27869 {
27870 if (!wxPyCheckForApp()) SWIG_fail;
27871 PyThreadState* __tstate = wxPyBeginAllowThreads();
27872 result = (wxWindow *)wxWindow::FindFocus();
27873
27874 wxPyEndAllowThreads(__tstate);
27875 if (PyErr_Occurred()) SWIG_fail;
27876 }
27877 {
27878 resultobj = wxPyMake_wxObject(result, 0);
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj;
27888 wxWindow *arg1 = (wxWindow *) 0 ;
27889 bool result;
27890 PyObject * obj0 = 0 ;
27891 char *kwnames[] = {
27892 (char *) "self", NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27901
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 {
27906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27907 }
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxWindow *arg1 = (wxWindow *) 0 ;
27917 bool result;
27918 PyObject * obj0 = 0 ;
27919 char *kwnames[] = {
27920 (char *) "self", NULL
27921 };
27922
27923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27925 if (SWIG_arg_fail(1)) SWIG_fail;
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27929
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 {
27934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27935 }
27936 return resultobj;
27937 fail:
27938 return NULL;
27939 }
27940
27941
27942 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj;
27944 wxWindow *arg1 = (wxWindow *) 0 ;
27945 wxWindow *result;
27946 PyObject * obj0 = 0 ;
27947 char *kwnames[] = {
27948 (char *) "self", NULL
27949 };
27950
27951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27953 if (SWIG_arg_fail(1)) SWIG_fail;
27954 {
27955 PyThreadState* __tstate = wxPyBeginAllowThreads();
27956 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27957
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 {
27962 resultobj = wxPyMake_wxObject(result, 0);
27963 }
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27971 PyObject *resultobj;
27972 wxWindow *arg1 = (wxWindow *) 0 ;
27973 wxWindow *arg2 = (wxWindow *) 0 ;
27974 wxWindow *result;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char *kwnames[] = {
27978 (char *) "self",(char *) "child", NULL
27979 };
27980
27981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27983 if (SWIG_arg_fail(1)) SWIG_fail;
27984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(2)) SWIG_fail;
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27989
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 {
27994 resultobj = wxPyMake_wxObject(result, 0);
27995 }
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj;
28004 wxWindow *arg1 = (wxWindow *) 0 ;
28005 wxWindow *arg2 = (wxWindow *) 0 ;
28006 PyObject * obj0 = 0 ;
28007 PyObject * obj1 = 0 ;
28008 char *kwnames[] = {
28009 (char *) "self",(char *) "win", NULL
28010 };
28011
28012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28014 if (SWIG_arg_fail(1)) SWIG_fail;
28015 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28016 if (SWIG_arg_fail(2)) SWIG_fail;
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 (arg1)->SetTmpDefaultItem(arg2);
28020
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 Py_INCREF(Py_None); resultobj = Py_None;
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj;
28033 wxWindow *arg1 = (wxWindow *) 0 ;
28034 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28035 bool result;
28036 PyObject * obj0 = 0 ;
28037 PyObject * obj1 = 0 ;
28038 char *kwnames[] = {
28039 (char *) "self",(char *) "flags", NULL
28040 };
28041
28042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28044 if (SWIG_arg_fail(1)) SWIG_fail;
28045 if (obj1) {
28046 {
28047 arg2 = (int)(SWIG_As_int(obj1));
28048 if (SWIG_arg_fail(2)) SWIG_fail;
28049 }
28050 }
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 result = (bool)(arg1)->Navigate(arg2);
28054
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 {
28059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28060 }
28061 return resultobj;
28062 fail:
28063 return NULL;
28064 }
28065
28066
28067 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28068 PyObject *resultobj;
28069 wxWindow *arg1 = (wxWindow *) 0 ;
28070 wxWindow *arg2 = (wxWindow *) 0 ;
28071 PyObject * obj0 = 0 ;
28072 PyObject * obj1 = 0 ;
28073 char *kwnames[] = {
28074 (char *) "self",(char *) "win", NULL
28075 };
28076
28077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28079 if (SWIG_arg_fail(1)) SWIG_fail;
28080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28081 if (SWIG_arg_fail(2)) SWIG_fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 (arg1)->MoveAfterInTabOrder(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_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj;
28098 wxWindow *arg1 = (wxWindow *) 0 ;
28099 wxWindow *arg2 = (wxWindow *) 0 ;
28100 PyObject * obj0 = 0 ;
28101 PyObject * obj1 = 0 ;
28102 char *kwnames[] = {
28103 (char *) "self",(char *) "win", NULL
28104 };
28105
28106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28108 if (SWIG_arg_fail(1)) SWIG_fail;
28109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28110 if (SWIG_arg_fail(2)) SWIG_fail;
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 (arg1)->MoveBeforeInTabOrder(arg2);
28114
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 Py_INCREF(Py_None); resultobj = Py_None;
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj;
28127 wxWindow *arg1 = (wxWindow *) 0 ;
28128 PyObject *result;
28129 PyObject * obj0 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = (PyObject *)wxWindow_GetChildren(arg1);
28140
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = result;
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj;
28153 wxWindow *arg1 = (wxWindow *) 0 ;
28154 wxWindow *result;
28155 PyObject * obj0 = 0 ;
28156 char *kwnames[] = {
28157 (char *) "self", NULL
28158 };
28159
28160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28162 if (SWIG_arg_fail(1)) SWIG_fail;
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 {
28171 resultobj = wxPyMake_wxObject(result, 0);
28172 }
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj;
28181 wxWindow *arg1 = (wxWindow *) 0 ;
28182 wxWindow *result;
28183 PyObject * obj0 = 0 ;
28184 char *kwnames[] = {
28185 (char *) "self", NULL
28186 };
28187
28188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28190 if (SWIG_arg_fail(1)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28194
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 {
28199 resultobj = wxPyMake_wxObject(result, 0);
28200 }
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj;
28209 wxWindow *arg1 = (wxWindow *) 0 ;
28210 bool result;
28211 PyObject * obj0 = 0 ;
28212 char *kwnames[] = {
28213 (char *) "self", NULL
28214 };
28215
28216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",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 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28222
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 {
28227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28228 }
28229 return resultobj;
28230 fail:
28231 return NULL;
28232 }
28233
28234
28235 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28236 PyObject *resultobj;
28237 wxWindow *arg1 = (wxWindow *) 0 ;
28238 wxWindow *arg2 = (wxWindow *) 0 ;
28239 bool result;
28240 PyObject * obj0 = 0 ;
28241 PyObject * obj1 = 0 ;
28242 char *kwnames[] = {
28243 (char *) "self",(char *) "newParent", NULL
28244 };
28245
28246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28248 if (SWIG_arg_fail(1)) SWIG_fail;
28249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28250 if (SWIG_arg_fail(2)) SWIG_fail;
28251 {
28252 PyThreadState* __tstate = wxPyBeginAllowThreads();
28253 result = (bool)(arg1)->Reparent(arg2);
28254
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 {
28259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28260 }
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj;
28269 wxWindow *arg1 = (wxWindow *) 0 ;
28270 wxWindow *arg2 = (wxWindow *) 0 ;
28271 PyObject * obj0 = 0 ;
28272 PyObject * obj1 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self",(char *) "child", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(2)) SWIG_fail;
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 (arg1)->AddChild(arg2);
28285
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 Py_INCREF(Py_None); resultobj = Py_None;
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj;
28298 wxWindow *arg1 = (wxWindow *) 0 ;
28299 wxWindow *arg2 = (wxWindow *) 0 ;
28300 PyObject * obj0 = 0 ;
28301 PyObject * obj1 = 0 ;
28302 char *kwnames[] = {
28303 (char *) "self",(char *) "child", NULL
28304 };
28305
28306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28308 if (SWIG_arg_fail(1)) SWIG_fail;
28309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28310 if (SWIG_arg_fail(2)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 (arg1)->RemoveChild(arg2);
28314
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 Py_INCREF(Py_None); resultobj = Py_None;
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj;
28327 wxWindow *arg1 = (wxWindow *) 0 ;
28328 long arg2 ;
28329 wxWindow *result;
28330 PyObject * obj0 = 0 ;
28331 PyObject * obj1 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self",(char *) "winid", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 arg2 = (long)(SWIG_As_long(obj1));
28341 if (SWIG_arg_fail(2)) SWIG_fail;
28342 }
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (wxWindow *)(arg1)->FindWindow(arg2);
28346
28347 wxPyEndAllowThreads(__tstate);
28348 if (PyErr_Occurred()) SWIG_fail;
28349 }
28350 {
28351 resultobj = wxPyMake_wxObject(result, 0);
28352 }
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxWindow *arg1 = (wxWindow *) 0 ;
28362 wxString *arg2 = 0 ;
28363 wxWindow *result;
28364 bool temp2 = false ;
28365 PyObject * obj0 = 0 ;
28366 PyObject * obj1 = 0 ;
28367 char *kwnames[] = {
28368 (char *) "self",(char *) "name", NULL
28369 };
28370
28371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28373 if (SWIG_arg_fail(1)) SWIG_fail;
28374 {
28375 arg2 = wxString_in_helper(obj1);
28376 if (arg2 == NULL) SWIG_fail;
28377 temp2 = true;
28378 }
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28382
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 {
28387 resultobj = wxPyMake_wxObject(result, 0);
28388 }
28389 {
28390 if (temp2)
28391 delete arg2;
28392 }
28393 return resultobj;
28394 fail:
28395 {
28396 if (temp2)
28397 delete arg2;
28398 }
28399 return NULL;
28400 }
28401
28402
28403 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28404 PyObject *resultobj;
28405 wxWindow *arg1 = (wxWindow *) 0 ;
28406 wxEvtHandler *result;
28407 PyObject * obj0 = 0 ;
28408 char *kwnames[] = {
28409 (char *) "self", NULL
28410 };
28411
28412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28414 if (SWIG_arg_fail(1)) SWIG_fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28418
28419 wxPyEndAllowThreads(__tstate);
28420 if (PyErr_Occurred()) SWIG_fail;
28421 }
28422 {
28423 resultobj = wxPyMake_wxObject(result, 0);
28424 }
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj;
28433 wxWindow *arg1 = (wxWindow *) 0 ;
28434 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28435 PyObject * obj0 = 0 ;
28436 PyObject * obj1 = 0 ;
28437 char *kwnames[] = {
28438 (char *) "self",(char *) "handler", NULL
28439 };
28440
28441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28443 if (SWIG_arg_fail(1)) SWIG_fail;
28444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28445 if (SWIG_arg_fail(2)) SWIG_fail;
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 (arg1)->SetEventHandler(arg2);
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 Py_INCREF(Py_None); resultobj = Py_None;
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28461 PyObject *resultobj;
28462 wxWindow *arg1 = (wxWindow *) 0 ;
28463 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28464 PyObject * obj0 = 0 ;
28465 PyObject * obj1 = 0 ;
28466 char *kwnames[] = {
28467 (char *) "self",(char *) "handler", NULL
28468 };
28469
28470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28472 if (SWIG_arg_fail(1)) SWIG_fail;
28473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(2)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 (arg1)->PushEventHandler(arg2);
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 Py_INCREF(Py_None); resultobj = Py_None;
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28490 PyObject *resultobj;
28491 wxWindow *arg1 = (wxWindow *) 0 ;
28492 bool arg2 = (bool) false ;
28493 wxEvtHandler *result;
28494 PyObject * obj0 = 0 ;
28495 PyObject * obj1 = 0 ;
28496 char *kwnames[] = {
28497 (char *) "self",(char *) "deleteHandler", NULL
28498 };
28499
28500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28502 if (SWIG_arg_fail(1)) SWIG_fail;
28503 if (obj1) {
28504 {
28505 arg2 = (bool)(SWIG_As_bool(obj1));
28506 if (SWIG_arg_fail(2)) SWIG_fail;
28507 }
28508 }
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28512
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 resultobj = wxPyMake_wxObject(result, 0);
28518 }
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28526 PyObject *resultobj;
28527 wxWindow *arg1 = (wxWindow *) 0 ;
28528 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28529 bool result;
28530 PyObject * obj0 = 0 ;
28531 PyObject * obj1 = 0 ;
28532 char *kwnames[] = {
28533 (char *) "self",(char *) "handler", NULL
28534 };
28535
28536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28538 if (SWIG_arg_fail(1)) SWIG_fail;
28539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(2)) SWIG_fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (bool)(arg1)->RemoveEventHandler(arg2);
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28558 PyObject *resultobj;
28559 wxWindow *arg1 = (wxWindow *) 0 ;
28560 wxValidator *arg2 = 0 ;
28561 PyObject * obj0 = 0 ;
28562 PyObject * obj1 = 0 ;
28563 char *kwnames[] = {
28564 (char *) "self",(char *) "validator", NULL
28565 };
28566
28567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28569 if (SWIG_arg_fail(1)) SWIG_fail;
28570 {
28571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28572 if (SWIG_arg_fail(2)) SWIG_fail;
28573 if (arg2 == NULL) {
28574 SWIG_null_ref("wxValidator");
28575 }
28576 if (SWIG_arg_fail(2)) SWIG_fail;
28577 }
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 (arg1)->SetValidator((wxValidator const &)*arg2);
28581
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 Py_INCREF(Py_None); resultobj = Py_None;
28586 return resultobj;
28587 fail:
28588 return NULL;
28589 }
28590
28591
28592 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28593 PyObject *resultobj;
28594 wxWindow *arg1 = (wxWindow *) 0 ;
28595 wxValidator *result;
28596 PyObject * obj0 = 0 ;
28597 char *kwnames[] = {
28598 (char *) "self", NULL
28599 };
28600
28601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28603 if (SWIG_arg_fail(1)) SWIG_fail;
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (wxValidator *)(arg1)->GetValidator();
28607
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 {
28612 resultobj = wxPyMake_wxObject(result, 0);
28613 }
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28621 PyObject *resultobj;
28622 wxWindow *arg1 = (wxWindow *) 0 ;
28623 bool result;
28624 PyObject * obj0 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "self", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(1)) SWIG_fail;
28632 {
28633 PyThreadState* __tstate = wxPyBeginAllowThreads();
28634 result = (bool)(arg1)->Validate();
28635
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 {
28640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28641 }
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj;
28650 wxWindow *arg1 = (wxWindow *) 0 ;
28651 bool result;
28652 PyObject * obj0 = 0 ;
28653 char *kwnames[] = {
28654 (char *) "self", NULL
28655 };
28656
28657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28659 if (SWIG_arg_fail(1)) SWIG_fail;
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 result = (bool)(arg1)->TransferDataToWindow();
28663
28664 wxPyEndAllowThreads(__tstate);
28665 if (PyErr_Occurred()) SWIG_fail;
28666 }
28667 {
28668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28669 }
28670 return resultobj;
28671 fail:
28672 return NULL;
28673 }
28674
28675
28676 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj;
28678 wxWindow *arg1 = (wxWindow *) 0 ;
28679 bool result;
28680 PyObject * obj0 = 0 ;
28681 char *kwnames[] = {
28682 (char *) "self", NULL
28683 };
28684
28685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28687 if (SWIG_arg_fail(1)) SWIG_fail;
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 result = (bool)(arg1)->TransferDataFromWindow();
28691
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 {
28696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28697 }
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj;
28706 wxWindow *arg1 = (wxWindow *) 0 ;
28707 PyObject * obj0 = 0 ;
28708 char *kwnames[] = {
28709 (char *) "self", NULL
28710 };
28711
28712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28714 if (SWIG_arg_fail(1)) SWIG_fail;
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 (arg1)->InitDialog();
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 Py_INCREF(Py_None); resultobj = Py_None;
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxWindow *arg1 = (wxWindow *) 0 ;
28732 wxAcceleratorTable *arg2 = 0 ;
28733 PyObject * obj0 = 0 ;
28734 PyObject * obj1 = 0 ;
28735 char *kwnames[] = {
28736 (char *) "self",(char *) "accel", NULL
28737 };
28738
28739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28741 if (SWIG_arg_fail(1)) SWIG_fail;
28742 {
28743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28744 if (SWIG_arg_fail(2)) SWIG_fail;
28745 if (arg2 == NULL) {
28746 SWIG_null_ref("wxAcceleratorTable");
28747 }
28748 if (SWIG_arg_fail(2)) SWIG_fail;
28749 }
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 Py_INCREF(Py_None); resultobj = Py_None;
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28765 PyObject *resultobj;
28766 wxWindow *arg1 = (wxWindow *) 0 ;
28767 wxAcceleratorTable *result;
28768 PyObject * obj0 = 0 ;
28769 char *kwnames[] = {
28770 (char *) "self", NULL
28771 };
28772
28773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28775 if (SWIG_arg_fail(1)) SWIG_fail;
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28779
28780 wxPyEndAllowThreads(__tstate);
28781 if (PyErr_Occurred()) SWIG_fail;
28782 }
28783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28791 PyObject *resultobj;
28792 wxWindow *arg1 = (wxWindow *) 0 ;
28793 int arg2 ;
28794 int arg3 ;
28795 int arg4 ;
28796 bool result;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 PyObject * obj2 = 0 ;
28800 PyObject * obj3 = 0 ;
28801 char *kwnames[] = {
28802 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28803 };
28804
28805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28807 if (SWIG_arg_fail(1)) SWIG_fail;
28808 {
28809 arg2 = (int)(SWIG_As_int(obj1));
28810 if (SWIG_arg_fail(2)) SWIG_fail;
28811 }
28812 {
28813 arg3 = (int)(SWIG_As_int(obj2));
28814 if (SWIG_arg_fail(3)) SWIG_fail;
28815 }
28816 {
28817 arg4 = (int)(SWIG_As_int(obj3));
28818 if (SWIG_arg_fail(4)) SWIG_fail;
28819 }
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28823
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 {
28828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28829 }
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj;
28838 wxWindow *arg1 = (wxWindow *) 0 ;
28839 int arg2 ;
28840 bool result;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 char *kwnames[] = {
28844 (char *) "self",(char *) "hotkeyId", NULL
28845 };
28846
28847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28849 if (SWIG_arg_fail(1)) SWIG_fail;
28850 {
28851 arg2 = (int)(SWIG_As_int(obj1));
28852 if (SWIG_arg_fail(2)) SWIG_fail;
28853 }
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 {
28862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28863 }
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj;
28872 wxWindow *arg1 = (wxWindow *) 0 ;
28873 wxPoint *arg2 = 0 ;
28874 wxPoint result;
28875 wxPoint temp2 ;
28876 PyObject * obj0 = 0 ;
28877 PyObject * obj1 = 0 ;
28878 char *kwnames[] = {
28879 (char *) "self",(char *) "pt", NULL
28880 };
28881
28882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28884 if (SWIG_arg_fail(1)) SWIG_fail;
28885 {
28886 arg2 = &temp2;
28887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28888 }
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28892
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 {
28897 wxPoint * resultptr;
28898 resultptr = new wxPoint((wxPoint &)(result));
28899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28900 }
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxWindow *arg1 = (wxWindow *) 0 ;
28910 wxSize *arg2 = 0 ;
28911 wxSize result;
28912 wxSize temp2 ;
28913 PyObject * obj0 = 0 ;
28914 PyObject * obj1 = 0 ;
28915 char *kwnames[] = {
28916 (char *) "self",(char *) "sz", NULL
28917 };
28918
28919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(1)) SWIG_fail;
28922 {
28923 arg2 = &temp2;
28924 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28925 }
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 {
28934 wxSize * resultptr;
28935 resultptr = new wxSize((wxSize &)(result));
28936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28937 }
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28945 PyObject *resultobj;
28946 wxWindow *arg1 = (wxWindow *) 0 ;
28947 wxPoint *arg2 = 0 ;
28948 wxPoint result;
28949 wxPoint temp2 ;
28950 PyObject * obj0 = 0 ;
28951 PyObject * obj1 = 0 ;
28952 char *kwnames[] = {
28953 (char *) "self",(char *) "pt", NULL
28954 };
28955
28956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28958 if (SWIG_arg_fail(1)) SWIG_fail;
28959 {
28960 arg2 = &temp2;
28961 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28962 }
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 wxPoint * resultptr;
28972 resultptr = new wxPoint((wxPoint &)(result));
28973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28974 }
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28982 PyObject *resultobj;
28983 wxWindow *arg1 = (wxWindow *) 0 ;
28984 wxSize *arg2 = 0 ;
28985 wxSize result;
28986 wxSize temp2 ;
28987 PyObject * obj0 = 0 ;
28988 PyObject * obj1 = 0 ;
28989 char *kwnames[] = {
28990 (char *) "self",(char *) "sz", NULL
28991 };
28992
28993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28995 if (SWIG_arg_fail(1)) SWIG_fail;
28996 {
28997 arg2 = &temp2;
28998 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28999 }
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29003
29004 wxPyEndAllowThreads(__tstate);
29005 if (PyErr_Occurred()) SWIG_fail;
29006 }
29007 {
29008 wxSize * resultptr;
29009 resultptr = new wxSize((wxSize &)(result));
29010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29011 }
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj;
29020 wxWindow *arg1 = (wxWindow *) 0 ;
29021 wxPoint *arg2 = 0 ;
29022 wxPoint result;
29023 wxPoint temp2 ;
29024 PyObject * obj0 = 0 ;
29025 PyObject * obj1 = 0 ;
29026 char *kwnames[] = {
29027 (char *) "self",(char *) "pt", NULL
29028 };
29029
29030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29032 if (SWIG_arg_fail(1)) SWIG_fail;
29033 {
29034 arg2 = &temp2;
29035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29036 }
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29040
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 {
29045 wxPoint * resultptr;
29046 resultptr = new wxPoint((wxPoint &)(result));
29047 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29048 }
29049 return resultobj;
29050 fail:
29051 return NULL;
29052 }
29053
29054
29055 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29056 PyObject *resultobj;
29057 wxWindow *arg1 = (wxWindow *) 0 ;
29058 wxSize *arg2 = 0 ;
29059 wxSize result;
29060 wxSize temp2 ;
29061 PyObject * obj0 = 0 ;
29062 PyObject * obj1 = 0 ;
29063 char *kwnames[] = {
29064 (char *) "self",(char *) "sz", NULL
29065 };
29066
29067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29069 if (SWIG_arg_fail(1)) SWIG_fail;
29070 {
29071 arg2 = &temp2;
29072 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29073 }
29074 {
29075 PyThreadState* __tstate = wxPyBeginAllowThreads();
29076 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29077
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 {
29082 wxSize * resultptr;
29083 resultptr = new wxSize((wxSize &)(result));
29084 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29085 }
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj;
29094 wxWindow *arg1 = (wxWindow *) 0 ;
29095 int arg2 ;
29096 int arg3 ;
29097 PyObject * obj0 = 0 ;
29098 PyObject * obj1 = 0 ;
29099 PyObject * obj2 = 0 ;
29100 char *kwnames[] = {
29101 (char *) "self",(char *) "x",(char *) "y", NULL
29102 };
29103
29104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29106 if (SWIG_arg_fail(1)) SWIG_fail;
29107 {
29108 arg2 = (int)(SWIG_As_int(obj1));
29109 if (SWIG_arg_fail(2)) SWIG_fail;
29110 }
29111 {
29112 arg3 = (int)(SWIG_As_int(obj2));
29113 if (SWIG_arg_fail(3)) SWIG_fail;
29114 }
29115 {
29116 PyThreadState* __tstate = wxPyBeginAllowThreads();
29117 (arg1)->WarpPointer(arg2,arg3);
29118
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 Py_INCREF(Py_None); resultobj = Py_None;
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29130 PyObject *resultobj;
29131 wxWindow *arg1 = (wxWindow *) 0 ;
29132 PyObject * obj0 = 0 ;
29133 char *kwnames[] = {
29134 (char *) "self", NULL
29135 };
29136
29137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29139 if (SWIG_arg_fail(1)) SWIG_fail;
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 (arg1)->CaptureMouse();
29143
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 Py_INCREF(Py_None); resultobj = Py_None;
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj;
29156 wxWindow *arg1 = (wxWindow *) 0 ;
29157 PyObject * obj0 = 0 ;
29158 char *kwnames[] = {
29159 (char *) "self", NULL
29160 };
29161
29162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29164 if (SWIG_arg_fail(1)) SWIG_fail;
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 (arg1)->ReleaseMouse();
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 Py_INCREF(Py_None); resultobj = Py_None;
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj;
29181 wxWindow *result;
29182 char *kwnames[] = {
29183 NULL
29184 };
29185
29186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29187 {
29188 if (!wxPyCheckForApp()) SWIG_fail;
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxWindow *)wxWindow::GetCapture();
29191
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 {
29196 resultobj = wxPyMake_wxObject(result, 0);
29197 }
29198 return resultobj;
29199 fail:
29200 return NULL;
29201 }
29202
29203
29204 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29205 PyObject *resultobj;
29206 wxWindow *arg1 = (wxWindow *) 0 ;
29207 bool result;
29208 PyObject * obj0 = 0 ;
29209 char *kwnames[] = {
29210 (char *) "self", NULL
29211 };
29212
29213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29215 if (SWIG_arg_fail(1)) SWIG_fail;
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 result = (bool)((wxWindow const *)arg1)->HasCapture();
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 {
29224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29225 }
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxWindow *arg1 = (wxWindow *) 0 ;
29235 bool arg2 = (bool) true ;
29236 wxRect *arg3 = (wxRect *) NULL ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char *kwnames[] = {
29241 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29242 };
29243
29244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(1)) SWIG_fail;
29247 if (obj1) {
29248 {
29249 arg2 = (bool)(SWIG_As_bool(obj1));
29250 if (SWIG_arg_fail(2)) SWIG_fail;
29251 }
29252 }
29253 if (obj2) {
29254 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29255 if (SWIG_arg_fail(3)) SWIG_fail;
29256 }
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29260
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 Py_INCREF(Py_None); resultobj = Py_None;
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj;
29273 wxWindow *arg1 = (wxWindow *) 0 ;
29274 wxRect *arg2 = 0 ;
29275 bool arg3 = (bool) true ;
29276 wxRect temp2 ;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 PyObject * obj2 = 0 ;
29280 char *kwnames[] = {
29281 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29282 };
29283
29284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29286 if (SWIG_arg_fail(1)) SWIG_fail;
29287 {
29288 arg2 = &temp2;
29289 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29290 }
29291 if (obj2) {
29292 {
29293 arg3 = (bool)(SWIG_As_bool(obj2));
29294 if (SWIG_arg_fail(3)) SWIG_fail;
29295 }
29296 }
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29300
29301 wxPyEndAllowThreads(__tstate);
29302 if (PyErr_Occurred()) SWIG_fail;
29303 }
29304 Py_INCREF(Py_None); resultobj = Py_None;
29305 return resultobj;
29306 fail:
29307 return NULL;
29308 }
29309
29310
29311 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29312 PyObject *resultobj;
29313 wxWindow *arg1 = (wxWindow *) 0 ;
29314 PyObject * obj0 = 0 ;
29315 char *kwnames[] = {
29316 (char *) "self", NULL
29317 };
29318
29319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29321 if (SWIG_arg_fail(1)) SWIG_fail;
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 (arg1)->Update();
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 Py_INCREF(Py_None); resultobj = Py_None;
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj;
29338 wxWindow *arg1 = (wxWindow *) 0 ;
29339 PyObject * obj0 = 0 ;
29340 char *kwnames[] = {
29341 (char *) "self", NULL
29342 };
29343
29344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29346 if (SWIG_arg_fail(1)) SWIG_fail;
29347 {
29348 PyThreadState* __tstate = wxPyBeginAllowThreads();
29349 (arg1)->ClearBackground();
29350
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 Py_INCREF(Py_None); resultobj = Py_None;
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29362 PyObject *resultobj;
29363 wxWindow *arg1 = (wxWindow *) 0 ;
29364 PyObject * obj0 = 0 ;
29365 char *kwnames[] = {
29366 (char *) "self", NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29371 if (SWIG_arg_fail(1)) SWIG_fail;
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 (arg1)->Freeze();
29375
29376 wxPyEndAllowThreads(__tstate);
29377 if (PyErr_Occurred()) SWIG_fail;
29378 }
29379 Py_INCREF(Py_None); resultobj = Py_None;
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj;
29388 wxWindow *arg1 = (wxWindow *) 0 ;
29389 PyObject * obj0 = 0 ;
29390 char *kwnames[] = {
29391 (char *) "self", NULL
29392 };
29393
29394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29396 if (SWIG_arg_fail(1)) SWIG_fail;
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 (arg1)->Thaw();
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 Py_INCREF(Py_None); resultobj = Py_None;
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29412 PyObject *resultobj;
29413 wxWindow *arg1 = (wxWindow *) 0 ;
29414 wxDC *arg2 = 0 ;
29415 PyObject * obj0 = 0 ;
29416 PyObject * obj1 = 0 ;
29417 char *kwnames[] = {
29418 (char *) "self",(char *) "dc", NULL
29419 };
29420
29421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29423 if (SWIG_arg_fail(1)) SWIG_fail;
29424 {
29425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29426 if (SWIG_arg_fail(2)) SWIG_fail;
29427 if (arg2 == NULL) {
29428 SWIG_null_ref("wxDC");
29429 }
29430 if (SWIG_arg_fail(2)) SWIG_fail;
29431 }
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 (arg1)->PrepareDC(*arg2);
29435
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 Py_INCREF(Py_None); resultobj = Py_None;
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj;
29448 wxWindow *arg1 = (wxWindow *) 0 ;
29449 wxRegion *result;
29450 PyObject * obj0 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 {
29461 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29462 result = (wxRegion *) &_result_ref;
29463 }
29464
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29469 return resultobj;
29470 fail:
29471 return NULL;
29472 }
29473
29474
29475 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29476 PyObject *resultobj;
29477 wxWindow *arg1 = (wxWindow *) 0 ;
29478 wxRect result;
29479 PyObject * obj0 = 0 ;
29480 char *kwnames[] = {
29481 (char *) "self", NULL
29482 };
29483
29484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29486 if (SWIG_arg_fail(1)) SWIG_fail;
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29490
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 {
29495 wxRect * resultptr;
29496 resultptr = new wxRect((wxRect &)(result));
29497 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29498 }
29499 return resultobj;
29500 fail:
29501 return NULL;
29502 }
29503
29504
29505 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29506 PyObject *resultobj;
29507 wxWindow *arg1 = (wxWindow *) 0 ;
29508 int arg2 ;
29509 int arg3 ;
29510 int arg4 = (int) 1 ;
29511 int arg5 = (int) 1 ;
29512 bool result;
29513 PyObject * obj0 = 0 ;
29514 PyObject * obj1 = 0 ;
29515 PyObject * obj2 = 0 ;
29516 PyObject * obj3 = 0 ;
29517 PyObject * obj4 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 arg2 = (int)(SWIG_As_int(obj1));
29527 if (SWIG_arg_fail(2)) SWIG_fail;
29528 }
29529 {
29530 arg3 = (int)(SWIG_As_int(obj2));
29531 if (SWIG_arg_fail(3)) SWIG_fail;
29532 }
29533 if (obj3) {
29534 {
29535 arg4 = (int)(SWIG_As_int(obj3));
29536 if (SWIG_arg_fail(4)) SWIG_fail;
29537 }
29538 }
29539 if (obj4) {
29540 {
29541 arg5 = (int)(SWIG_As_int(obj4));
29542 if (SWIG_arg_fail(5)) SWIG_fail;
29543 }
29544 }
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29548
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 {
29553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29554 }
29555 return resultobj;
29556 fail:
29557 return NULL;
29558 }
29559
29560
29561 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29562 PyObject *resultobj;
29563 wxWindow *arg1 = (wxWindow *) 0 ;
29564 wxPoint *arg2 = 0 ;
29565 bool result;
29566 wxPoint temp2 ;
29567 PyObject * obj0 = 0 ;
29568 PyObject * obj1 = 0 ;
29569 char *kwnames[] = {
29570 (char *) "self",(char *) "pt", NULL
29571 };
29572
29573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29575 if (SWIG_arg_fail(1)) SWIG_fail;
29576 {
29577 arg2 = &temp2;
29578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29579 }
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29583
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 {
29588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29589 }
29590 return resultobj;
29591 fail:
29592 return NULL;
29593 }
29594
29595
29596 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29597 PyObject *resultobj;
29598 wxWindow *arg1 = (wxWindow *) 0 ;
29599 wxRect *arg2 = 0 ;
29600 bool result;
29601 wxRect temp2 ;
29602 PyObject * obj0 = 0 ;
29603 PyObject * obj1 = 0 ;
29604 char *kwnames[] = {
29605 (char *) "self",(char *) "rect", NULL
29606 };
29607
29608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29610 if (SWIG_arg_fail(1)) SWIG_fail;
29611 {
29612 arg2 = &temp2;
29613 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29614 }
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29618
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 {
29623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29624 }
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj;
29633 wxWindow *arg1 = (wxWindow *) 0 ;
29634 wxVisualAttributes result;
29635 PyObject * obj0 = 0 ;
29636 char *kwnames[] = {
29637 (char *) "self", NULL
29638 };
29639
29640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29642 if (SWIG_arg_fail(1)) SWIG_fail;
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29646
29647 wxPyEndAllowThreads(__tstate);
29648 if (PyErr_Occurred()) SWIG_fail;
29649 }
29650 {
29651 wxVisualAttributes * resultptr;
29652 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29654 }
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj;
29663 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29664 wxVisualAttributes result;
29665 PyObject * obj0 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "variant", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29671 if (obj0) {
29672 {
29673 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 }
29676 }
29677 {
29678 if (!wxPyCheckForApp()) SWIG_fail;
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 wxVisualAttributes * resultptr;
29687 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj;
29698 wxWindow *arg1 = (wxWindow *) 0 ;
29699 wxColour *arg2 = 0 ;
29700 bool result;
29701 wxColour temp2 ;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self",(char *) "colour", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 {
29712 arg2 = &temp2;
29713 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29714 }
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29718
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj;
29733 wxWindow *arg1 = (wxWindow *) 0 ;
29734 wxColour *arg2 = 0 ;
29735 wxColour temp2 ;
29736 PyObject * obj0 = 0 ;
29737 PyObject * obj1 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self",(char *) "colour", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 arg2 = &temp2;
29747 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29748 }
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29752
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 Py_INCREF(Py_None); resultobj = Py_None;
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj;
29765 wxWindow *arg1 = (wxWindow *) 0 ;
29766 wxColour *arg2 = 0 ;
29767 bool result;
29768 wxColour temp2 ;
29769 PyObject * obj0 = 0 ;
29770 PyObject * obj1 = 0 ;
29771 char *kwnames[] = {
29772 (char *) "self",(char *) "colour", NULL
29773 };
29774
29775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 {
29779 arg2 = &temp2;
29780 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29781 }
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 {
29790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29791 }
29792 return resultobj;
29793 fail:
29794 return NULL;
29795 }
29796
29797
29798 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29799 PyObject *resultobj;
29800 wxWindow *arg1 = (wxWindow *) 0 ;
29801 wxColour *arg2 = 0 ;
29802 wxColour temp2 ;
29803 PyObject * obj0 = 0 ;
29804 PyObject * obj1 = 0 ;
29805 char *kwnames[] = {
29806 (char *) "self",(char *) "colour", NULL
29807 };
29808
29809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29811 if (SWIG_arg_fail(1)) SWIG_fail;
29812 {
29813 arg2 = &temp2;
29814 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29815 }
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29819
29820 wxPyEndAllowThreads(__tstate);
29821 if (PyErr_Occurred()) SWIG_fail;
29822 }
29823 Py_INCREF(Py_None); resultobj = Py_None;
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29831 PyObject *resultobj;
29832 wxWindow *arg1 = (wxWindow *) 0 ;
29833 wxColour result;
29834 PyObject * obj0 = 0 ;
29835 char *kwnames[] = {
29836 (char *) "self", NULL
29837 };
29838
29839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29841 if (SWIG_arg_fail(1)) SWIG_fail;
29842 {
29843 PyThreadState* __tstate = wxPyBeginAllowThreads();
29844 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29845
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 {
29850 wxColour * resultptr;
29851 resultptr = new wxColour((wxColour &)(result));
29852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29853 }
29854 return resultobj;
29855 fail:
29856 return NULL;
29857 }
29858
29859
29860 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29861 PyObject *resultobj;
29862 wxWindow *arg1 = (wxWindow *) 0 ;
29863 wxColour result;
29864 PyObject * obj0 = 0 ;
29865 char *kwnames[] = {
29866 (char *) "self", NULL
29867 };
29868
29869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29871 if (SWIG_arg_fail(1)) SWIG_fail;
29872 {
29873 PyThreadState* __tstate = wxPyBeginAllowThreads();
29874 result = ((wxWindow const *)arg1)->GetForegroundColour();
29875
29876 wxPyEndAllowThreads(__tstate);
29877 if (PyErr_Occurred()) SWIG_fail;
29878 }
29879 {
29880 wxColour * resultptr;
29881 resultptr = new wxColour((wxColour &)(result));
29882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29883 }
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29891 PyObject *resultobj;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 bool result;
29894 PyObject * obj0 = 0 ;
29895 char *kwnames[] = {
29896 (char *) "self", NULL
29897 };
29898
29899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29901 if (SWIG_arg_fail(1)) SWIG_fail;
29902 {
29903 PyThreadState* __tstate = wxPyBeginAllowThreads();
29904 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29905
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 {
29910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29911 }
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 bool result;
29922 PyObject * obj0 = 0 ;
29923 char *kwnames[] = {
29924 (char *) "self", NULL
29925 };
29926
29927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29929 if (SWIG_arg_fail(1)) SWIG_fail;
29930 {
29931 PyThreadState* __tstate = wxPyBeginAllowThreads();
29932 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29933
29934 wxPyEndAllowThreads(__tstate);
29935 if (PyErr_Occurred()) SWIG_fail;
29936 }
29937 {
29938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29939 }
29940 return resultobj;
29941 fail:
29942 return NULL;
29943 }
29944
29945
29946 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29947 PyObject *resultobj;
29948 wxWindow *arg1 = (wxWindow *) 0 ;
29949 wxBackgroundStyle arg2 ;
29950 bool result;
29951 PyObject * obj0 = 0 ;
29952 PyObject * obj1 = 0 ;
29953 char *kwnames[] = {
29954 (char *) "self",(char *) "style", NULL
29955 };
29956
29957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) 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 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29962 if (SWIG_arg_fail(2)) SWIG_fail;
29963 }
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29973 }
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxWindow *arg1 = (wxWindow *) 0 ;
29983 wxBackgroundStyle result;
29984 PyObject * obj0 = 0 ;
29985 char *kwnames[] = {
29986 (char *) "self", NULL
29987 };
29988
29989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29991 if (SWIG_arg_fail(1)) SWIG_fail;
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29995
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 resultobj = SWIG_From_int((result));
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 bool result;
30010 PyObject * obj0 = 0 ;
30011 char *kwnames[] = {
30012 (char *) "self", NULL
30013 };
30014
30015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(1)) SWIG_fail;
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 result = (bool)(arg1)->HasTransparentBackground();
30021
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 {
30026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30027 }
30028 return resultobj;
30029 fail:
30030 return NULL;
30031 }
30032
30033
30034 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30035 PyObject *resultobj;
30036 wxWindow *arg1 = (wxWindow *) 0 ;
30037 wxCursor *arg2 = 0 ;
30038 bool result;
30039 PyObject * obj0 = 0 ;
30040 PyObject * obj1 = 0 ;
30041 char *kwnames[] = {
30042 (char *) "self",(char *) "cursor", NULL
30043 };
30044
30045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30047 if (SWIG_arg_fail(1)) SWIG_fail;
30048 {
30049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30050 if (SWIG_arg_fail(2)) SWIG_fail;
30051 if (arg2 == NULL) {
30052 SWIG_null_ref("wxCursor");
30053 }
30054 if (SWIG_arg_fail(2)) SWIG_fail;
30055 }
30056 {
30057 PyThreadState* __tstate = wxPyBeginAllowThreads();
30058 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30059
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 {
30064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30065 }
30066 return resultobj;
30067 fail:
30068 return NULL;
30069 }
30070
30071
30072 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30073 PyObject *resultobj;
30074 wxWindow *arg1 = (wxWindow *) 0 ;
30075 wxCursor result;
30076 PyObject * obj0 = 0 ;
30077 char *kwnames[] = {
30078 (char *) "self", NULL
30079 };
30080
30081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 result = (arg1)->GetCursor();
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 wxCursor * resultptr;
30093 resultptr = new wxCursor((wxCursor &)(result));
30094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30095 }
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30103 PyObject *resultobj;
30104 wxWindow *arg1 = (wxWindow *) 0 ;
30105 wxFont *arg2 = 0 ;
30106 bool result;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 char *kwnames[] = {
30110 (char *) "self",(char *) "font", NULL
30111 };
30112
30113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30115 if (SWIG_arg_fail(1)) SWIG_fail;
30116 {
30117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30118 if (SWIG_arg_fail(2)) SWIG_fail;
30119 if (arg2 == NULL) {
30120 SWIG_null_ref("wxFont");
30121 }
30122 if (SWIG_arg_fail(2)) SWIG_fail;
30123 }
30124 {
30125 PyThreadState* __tstate = wxPyBeginAllowThreads();
30126 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30127
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 {
30132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30133 }
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30141 PyObject *resultobj;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 wxFont *arg2 = 0 ;
30144 PyObject * obj0 = 0 ;
30145 PyObject * obj1 = 0 ;
30146 char *kwnames[] = {
30147 (char *) "self",(char *) "font", NULL
30148 };
30149
30150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30152 if (SWIG_arg_fail(1)) SWIG_fail;
30153 {
30154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(2)) SWIG_fail;
30156 if (arg2 == NULL) {
30157 SWIG_null_ref("wxFont");
30158 }
30159 if (SWIG_arg_fail(2)) SWIG_fail;
30160 }
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 (arg1)->SetOwnFont((wxFont const &)*arg2);
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 wxWindow *arg1 = (wxWindow *) 0 ;
30178 wxFont result;
30179 PyObject * obj0 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = (arg1)->GetFont();
30190
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 {
30195 wxFont * resultptr;
30196 resultptr = new wxFont((wxFont &)(result));
30197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30198 }
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 wxWindow *arg1 = (wxWindow *) 0 ;
30208 wxCaret *arg2 = (wxCaret *) 0 ;
30209 PyObject * obj0 = 0 ;
30210 PyObject * obj1 = 0 ;
30211 char *kwnames[] = {
30212 (char *) "self",(char *) "caret", NULL
30213 };
30214
30215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30217 if (SWIG_arg_fail(1)) SWIG_fail;
30218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30219 if (SWIG_arg_fail(2)) SWIG_fail;
30220 {
30221 PyThreadState* __tstate = wxPyBeginAllowThreads();
30222 (arg1)->SetCaret(arg2);
30223
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 Py_INCREF(Py_None); resultobj = Py_None;
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30235 PyObject *resultobj;
30236 wxWindow *arg1 = (wxWindow *) 0 ;
30237 wxCaret *result;
30238 PyObject * obj0 = 0 ;
30239 char *kwnames[] = {
30240 (char *) "self", NULL
30241 };
30242
30243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30245 if (SWIG_arg_fail(1)) SWIG_fail;
30246 {
30247 PyThreadState* __tstate = wxPyBeginAllowThreads();
30248 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30249
30250 wxPyEndAllowThreads(__tstate);
30251 if (PyErr_Occurred()) SWIG_fail;
30252 }
30253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30254 return resultobj;
30255 fail:
30256 return NULL;
30257 }
30258
30259
30260 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30261 PyObject *resultobj;
30262 wxWindow *arg1 = (wxWindow *) 0 ;
30263 int result;
30264 PyObject * obj0 = 0 ;
30265 char *kwnames[] = {
30266 (char *) "self", NULL
30267 };
30268
30269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30271 if (SWIG_arg_fail(1)) SWIG_fail;
30272 {
30273 PyThreadState* __tstate = wxPyBeginAllowThreads();
30274 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30275
30276 wxPyEndAllowThreads(__tstate);
30277 if (PyErr_Occurred()) SWIG_fail;
30278 }
30279 {
30280 resultobj = SWIG_From_int((int)(result));
30281 }
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj;
30290 wxWindow *arg1 = (wxWindow *) 0 ;
30291 int result;
30292 PyObject * obj0 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30303
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 {
30308 resultobj = SWIG_From_int((int)(result));
30309 }
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj;
30318 wxWindow *arg1 = (wxWindow *) 0 ;
30319 wxString *arg2 = 0 ;
30320 int *arg3 = (int *) 0 ;
30321 int *arg4 = (int *) 0 ;
30322 bool temp2 = false ;
30323 int temp3 ;
30324 int res3 = 0 ;
30325 int temp4 ;
30326 int res4 = 0 ;
30327 PyObject * obj0 = 0 ;
30328 PyObject * obj1 = 0 ;
30329 char *kwnames[] = {
30330 (char *) "self",(char *) "string", NULL
30331 };
30332
30333 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30334 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) 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 {
30339 arg2 = wxString_in_helper(obj1);
30340 if (arg2 == NULL) SWIG_fail;
30341 temp2 = true;
30342 }
30343 {
30344 PyThreadState* __tstate = wxPyBeginAllowThreads();
30345 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30346
30347 wxPyEndAllowThreads(__tstate);
30348 if (PyErr_Occurred()) SWIG_fail;
30349 }
30350 Py_INCREF(Py_None); resultobj = Py_None;
30351 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30352 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30353 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30354 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30355 {
30356 if (temp2)
30357 delete arg2;
30358 }
30359 return resultobj;
30360 fail:
30361 {
30362 if (temp2)
30363 delete arg2;
30364 }
30365 return NULL;
30366 }
30367
30368
30369 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30370 PyObject *resultobj;
30371 wxWindow *arg1 = (wxWindow *) 0 ;
30372 wxString *arg2 = 0 ;
30373 int *arg3 = (int *) 0 ;
30374 int *arg4 = (int *) 0 ;
30375 int *arg5 = (int *) 0 ;
30376 int *arg6 = (int *) 0 ;
30377 wxFont *arg7 = (wxFont *) NULL ;
30378 bool temp2 = false ;
30379 int temp3 ;
30380 int res3 = 0 ;
30381 int temp4 ;
30382 int res4 = 0 ;
30383 int temp5 ;
30384 int res5 = 0 ;
30385 int temp6 ;
30386 int res6 = 0 ;
30387 PyObject * obj0 = 0 ;
30388 PyObject * obj1 = 0 ;
30389 PyObject * obj2 = 0 ;
30390 char *kwnames[] = {
30391 (char *) "self",(char *) "string",(char *) "font", NULL
30392 };
30393
30394 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30395 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30396 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30397 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30400 if (SWIG_arg_fail(1)) SWIG_fail;
30401 {
30402 arg2 = wxString_in_helper(obj1);
30403 if (arg2 == NULL) SWIG_fail;
30404 temp2 = true;
30405 }
30406 if (obj2) {
30407 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30408 if (SWIG_arg_fail(7)) SWIG_fail;
30409 }
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30413
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 Py_INCREF(Py_None); resultobj = Py_None;
30418 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30419 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30420 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30421 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30422 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30423 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30424 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30425 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30426 {
30427 if (temp2)
30428 delete arg2;
30429 }
30430 return resultobj;
30431 fail:
30432 {
30433 if (temp2)
30434 delete arg2;
30435 }
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 int *arg2 = (int *) 0 ;
30444 int *arg3 = (int *) 0 ;
30445 int temp2 ;
30446 int res2 = 0 ;
30447 int temp3 ;
30448 int res3 = 0 ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 char *kwnames[] = {
30453 (char *) "self",(char *) "x",(char *) "y", NULL
30454 };
30455
30456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) 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 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30461 temp2 = SWIG_As_int(obj1);
30462 if (SWIG_arg_fail(2)) SWIG_fail;
30463 arg2 = &temp2;
30464 res2 = SWIG_NEWOBJ;
30465 }
30466 }
30467 {
30468 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30469 temp3 = SWIG_As_int(obj2);
30470 if (SWIG_arg_fail(3)) SWIG_fail;
30471 arg3 = &temp3;
30472 res3 = SWIG_NEWOBJ;
30473 }
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 Py_INCREF(Py_None); resultobj = Py_None;
30483 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30484 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30485 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30486 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30494 PyObject *resultobj;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 int *arg2 = (int *) 0 ;
30497 int *arg3 = (int *) 0 ;
30498 int temp2 ;
30499 int res2 = 0 ;
30500 int temp3 ;
30501 int res3 = 0 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 PyObject * obj2 = 0 ;
30505 char *kwnames[] = {
30506 (char *) "self",(char *) "x",(char *) "y", NULL
30507 };
30508
30509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30511 if (SWIG_arg_fail(1)) SWIG_fail;
30512 {
30513 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30514 temp2 = SWIG_As_int(obj1);
30515 if (SWIG_arg_fail(2)) SWIG_fail;
30516 arg2 = &temp2;
30517 res2 = SWIG_NEWOBJ;
30518 }
30519 }
30520 {
30521 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30522 temp3 = SWIG_As_int(obj2);
30523 if (SWIG_arg_fail(3)) SWIG_fail;
30524 arg3 = &temp3;
30525 res3 = SWIG_NEWOBJ;
30526 }
30527 }
30528 {
30529 PyThreadState* __tstate = wxPyBeginAllowThreads();
30530 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30531
30532 wxPyEndAllowThreads(__tstate);
30533 if (PyErr_Occurred()) SWIG_fail;
30534 }
30535 Py_INCREF(Py_None); resultobj = Py_None;
30536 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30537 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30538 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30539 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj;
30548 wxWindow *arg1 = (wxWindow *) 0 ;
30549 wxPoint *arg2 = 0 ;
30550 wxPoint result;
30551 wxPoint temp2 ;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self",(char *) "pt", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 arg2 = &temp2;
30563 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30564 }
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30568
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 {
30573 wxPoint * resultptr;
30574 resultptr = new wxPoint((wxPoint &)(result));
30575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30576 }
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj;
30585 wxWindow *arg1 = (wxWindow *) 0 ;
30586 wxPoint *arg2 = 0 ;
30587 wxPoint result;
30588 wxPoint temp2 ;
30589 PyObject * obj0 = 0 ;
30590 PyObject * obj1 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self",(char *) "pt", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 {
30599 arg2 = &temp2;
30600 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30601 }
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30605
30606 wxPyEndAllowThreads(__tstate);
30607 if (PyErr_Occurred()) SWIG_fail;
30608 }
30609 {
30610 wxPoint * resultptr;
30611 resultptr = new wxPoint((wxPoint &)(result));
30612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30613 }
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30621 PyObject *resultobj;
30622 wxWindow *arg1 = (wxWindow *) 0 ;
30623 int arg2 ;
30624 int arg3 ;
30625 wxHitTest result;
30626 PyObject * obj0 = 0 ;
30627 PyObject * obj1 = 0 ;
30628 PyObject * obj2 = 0 ;
30629 char *kwnames[] = {
30630 (char *) "self",(char *) "x",(char *) "y", NULL
30631 };
30632
30633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30635 if (SWIG_arg_fail(1)) SWIG_fail;
30636 {
30637 arg2 = (int)(SWIG_As_int(obj1));
30638 if (SWIG_arg_fail(2)) SWIG_fail;
30639 }
30640 {
30641 arg3 = (int)(SWIG_As_int(obj2));
30642 if (SWIG_arg_fail(3)) SWIG_fail;
30643 }
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 resultobj = SWIG_From_int((result));
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30659 PyObject *resultobj;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxPoint *arg2 = 0 ;
30662 wxHitTest result;
30663 wxPoint temp2 ;
30664 PyObject * obj0 = 0 ;
30665 PyObject * obj1 = 0 ;
30666 char *kwnames[] = {
30667 (char *) "self",(char *) "pt", NULL
30668 };
30669
30670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30672 if (SWIG_arg_fail(1)) SWIG_fail;
30673 {
30674 arg2 = &temp2;
30675 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30676 }
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30680
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 resultobj = SWIG_From_int((result));
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30692 PyObject *resultobj;
30693 wxWindow *arg1 = (wxWindow *) 0 ;
30694 long arg2 ;
30695 wxBorder result;
30696 PyObject * obj0 = 0 ;
30697 PyObject * obj1 = 0 ;
30698
30699 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30701 if (SWIG_arg_fail(1)) SWIG_fail;
30702 {
30703 arg2 = (long)(SWIG_As_long(obj1));
30704 if (SWIG_arg_fail(2)) SWIG_fail;
30705 }
30706 {
30707 PyThreadState* __tstate = wxPyBeginAllowThreads();
30708 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30709
30710 wxPyEndAllowThreads(__tstate);
30711 if (PyErr_Occurred()) SWIG_fail;
30712 }
30713 resultobj = SWIG_From_int((result));
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30721 PyObject *resultobj;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 wxBorder result;
30724 PyObject * obj0 = 0 ;
30725
30726 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30728 if (SWIG_arg_fail(1)) SWIG_fail;
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30732
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 resultobj = SWIG_From_int((result));
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30744 int argc;
30745 PyObject *argv[3];
30746 int ii;
30747
30748 argc = PyObject_Length(args);
30749 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30750 argv[ii] = PyTuple_GetItem(args,ii);
30751 }
30752 if (argc == 1) {
30753 int _v;
30754 {
30755 void *ptr;
30756 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30757 _v = 0;
30758 PyErr_Clear();
30759 } else {
30760 _v = 1;
30761 }
30762 }
30763 if (_v) {
30764 return _wrap_Window_GetBorder__SWIG_1(self,args);
30765 }
30766 }
30767 if (argc == 2) {
30768 int _v;
30769 {
30770 void *ptr;
30771 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30772 _v = 0;
30773 PyErr_Clear();
30774 } else {
30775 _v = 1;
30776 }
30777 }
30778 if (_v) {
30779 _v = SWIG_Check_long(argv[1]);
30780 if (_v) {
30781 return _wrap_Window_GetBorder__SWIG_0(self,args);
30782 }
30783 }
30784 }
30785
30786 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30787 return NULL;
30788 }
30789
30790
30791 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 long arg2 = (long) wxUPDATE_UI_NONE ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 char *kwnames[] = {
30798 (char *) "self",(char *) "flags", NULL
30799 };
30800
30801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30803 if (SWIG_arg_fail(1)) SWIG_fail;
30804 if (obj1) {
30805 {
30806 arg2 = (long)(SWIG_As_long(obj1));
30807 if (SWIG_arg_fail(2)) SWIG_fail;
30808 }
30809 }
30810 {
30811 PyThreadState* __tstate = wxPyBeginAllowThreads();
30812 (arg1)->UpdateWindowUI(arg2);
30813
30814 wxPyEndAllowThreads(__tstate);
30815 if (PyErr_Occurred()) SWIG_fail;
30816 }
30817 Py_INCREF(Py_None); resultobj = Py_None;
30818 return resultobj;
30819 fail:
30820 return NULL;
30821 }
30822
30823
30824 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30825 PyObject *resultobj;
30826 wxWindow *arg1 = (wxWindow *) 0 ;
30827 wxMenu *arg2 = (wxMenu *) 0 ;
30828 int arg3 = (int) -1 ;
30829 int arg4 = (int) -1 ;
30830 bool result;
30831 PyObject * obj0 = 0 ;
30832 PyObject * obj1 = 0 ;
30833 PyObject * obj2 = 0 ;
30834 PyObject * obj3 = 0 ;
30835 char *kwnames[] = {
30836 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30837 };
30838
30839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(2)) SWIG_fail;
30844 if (obj2) {
30845 {
30846 arg3 = (int)(SWIG_As_int(obj2));
30847 if (SWIG_arg_fail(3)) SWIG_fail;
30848 }
30849 }
30850 if (obj3) {
30851 {
30852 arg4 = (int)(SWIG_As_int(obj3));
30853 if (SWIG_arg_fail(4)) SWIG_fail;
30854 }
30855 }
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxWindow *arg1 = (wxWindow *) 0 ;
30875 wxMenu *arg2 = (wxMenu *) 0 ;
30876 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30877 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30878 bool result;
30879 wxPoint temp3 ;
30880 PyObject * obj0 = 0 ;
30881 PyObject * obj1 = 0 ;
30882 PyObject * obj2 = 0 ;
30883 char *kwnames[] = {
30884 (char *) "self",(char *) "menu",(char *) "pos", NULL
30885 };
30886
30887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30889 if (SWIG_arg_fail(1)) SWIG_fail;
30890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30891 if (SWIG_arg_fail(2)) SWIG_fail;
30892 if (obj2) {
30893 {
30894 arg3 = &temp3;
30895 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30896 }
30897 }
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
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_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30915 PyObject *resultobj;
30916 wxWindow *arg1 = (wxWindow *) 0 ;
30917 long result;
30918 PyObject * obj0 = 0 ;
30919 char *kwnames[] = {
30920 (char *) "self", NULL
30921 };
30922
30923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",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 = (long)wxWindow_GetHandle(arg1);
30929
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 {
30934 resultobj = SWIG_From_long((long)(result));
30935 }
30936 return resultobj;
30937 fail:
30938 return NULL;
30939 }
30940
30941
30942 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30943 PyObject *resultobj;
30944 wxWindow *arg1 = (wxWindow *) 0 ;
30945 long arg2 ;
30946 PyObject * obj0 = 0 ;
30947 PyObject * obj1 = 0 ;
30948 char *kwnames[] = {
30949 (char *) "self",(char *) "handle", NULL
30950 };
30951
30952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30954 if (SWIG_arg_fail(1)) SWIG_fail;
30955 {
30956 arg2 = (long)(SWIG_As_long(obj1));
30957 if (SWIG_arg_fail(2)) SWIG_fail;
30958 }
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 wxWindow_AssociateHandle(arg1,arg2);
30962
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 Py_INCREF(Py_None); resultobj = Py_None;
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj;
30975 wxWindow *arg1 = (wxWindow *) 0 ;
30976 PyObject * obj0 = 0 ;
30977 char *kwnames[] = {
30978 (char *) "self", NULL
30979 };
30980
30981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30983 if (SWIG_arg_fail(1)) SWIG_fail;
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 (arg1)->DissociateHandle();
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 Py_INCREF(Py_None); resultobj = Py_None;
30992 return resultobj;
30993 fail:
30994 return NULL;
30995 }
30996
30997
30998 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30999 PyObject *resultobj;
31000 wxWindow *arg1 = (wxWindow *) 0 ;
31001 int arg2 ;
31002 bool result;
31003 PyObject * obj0 = 0 ;
31004 PyObject * obj1 = 0 ;
31005 char *kwnames[] = {
31006 (char *) "self",(char *) "orient", NULL
31007 };
31008
31009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31011 if (SWIG_arg_fail(1)) SWIG_fail;
31012 {
31013 arg2 = (int)(SWIG_As_int(obj1));
31014 if (SWIG_arg_fail(2)) SWIG_fail;
31015 }
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31019
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 {
31024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31025 }
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj;
31034 wxWindow *arg1 = (wxWindow *) 0 ;
31035 int arg2 ;
31036 int arg3 ;
31037 int arg4 ;
31038 int arg5 ;
31039 bool arg6 = (bool) true ;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 PyObject * obj2 = 0 ;
31043 PyObject * obj3 = 0 ;
31044 PyObject * obj4 = 0 ;
31045 PyObject * obj5 = 0 ;
31046 char *kwnames[] = {
31047 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31048 };
31049
31050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31052 if (SWIG_arg_fail(1)) SWIG_fail;
31053 {
31054 arg2 = (int)(SWIG_As_int(obj1));
31055 if (SWIG_arg_fail(2)) SWIG_fail;
31056 }
31057 {
31058 arg3 = (int)(SWIG_As_int(obj2));
31059 if (SWIG_arg_fail(3)) SWIG_fail;
31060 }
31061 {
31062 arg4 = (int)(SWIG_As_int(obj3));
31063 if (SWIG_arg_fail(4)) SWIG_fail;
31064 }
31065 {
31066 arg5 = (int)(SWIG_As_int(obj4));
31067 if (SWIG_arg_fail(5)) SWIG_fail;
31068 }
31069 if (obj5) {
31070 {
31071 arg6 = (bool)(SWIG_As_bool(obj5));
31072 if (SWIG_arg_fail(6)) SWIG_fail;
31073 }
31074 }
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31078
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 Py_INCREF(Py_None); resultobj = Py_None;
31083 return resultobj;
31084 fail:
31085 return NULL;
31086 }
31087
31088
31089 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31090 PyObject *resultobj;
31091 wxWindow *arg1 = (wxWindow *) 0 ;
31092 int arg2 ;
31093 int arg3 ;
31094 bool arg4 = (bool) true ;
31095 PyObject * obj0 = 0 ;
31096 PyObject * obj1 = 0 ;
31097 PyObject * obj2 = 0 ;
31098 PyObject * obj3 = 0 ;
31099 char *kwnames[] = {
31100 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31101 };
31102
31103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31105 if (SWIG_arg_fail(1)) SWIG_fail;
31106 {
31107 arg2 = (int)(SWIG_As_int(obj1));
31108 if (SWIG_arg_fail(2)) SWIG_fail;
31109 }
31110 {
31111 arg3 = (int)(SWIG_As_int(obj2));
31112 if (SWIG_arg_fail(3)) SWIG_fail;
31113 }
31114 if (obj3) {
31115 {
31116 arg4 = (bool)(SWIG_As_bool(obj3));
31117 if (SWIG_arg_fail(4)) SWIG_fail;
31118 }
31119 }
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 (arg1)->SetScrollPos(arg2,arg3,arg4);
31123
31124 wxPyEndAllowThreads(__tstate);
31125 if (PyErr_Occurred()) SWIG_fail;
31126 }
31127 Py_INCREF(Py_None); resultobj = Py_None;
31128 return resultobj;
31129 fail:
31130 return NULL;
31131 }
31132
31133
31134 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31135 PyObject *resultobj;
31136 wxWindow *arg1 = (wxWindow *) 0 ;
31137 int arg2 ;
31138 int result;
31139 PyObject * obj0 = 0 ;
31140 PyObject * obj1 = 0 ;
31141 char *kwnames[] = {
31142 (char *) "self",(char *) "orientation", NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31147 if (SWIG_arg_fail(1)) SWIG_fail;
31148 {
31149 arg2 = (int)(SWIG_As_int(obj1));
31150 if (SWIG_arg_fail(2)) SWIG_fail;
31151 }
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31155
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 {
31160 resultobj = SWIG_From_int((int)(result));
31161 }
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31169 PyObject *resultobj;
31170 wxWindow *arg1 = (wxWindow *) 0 ;
31171 int arg2 ;
31172 int result;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char *kwnames[] = {
31176 (char *) "self",(char *) "orientation", NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(1)) SWIG_fail;
31182 {
31183 arg2 = (int)(SWIG_As_int(obj1));
31184 if (SWIG_arg_fail(2)) SWIG_fail;
31185 }
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31189
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 {
31194 resultobj = SWIG_From_int((int)(result));
31195 }
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31203 PyObject *resultobj;
31204 wxWindow *arg1 = (wxWindow *) 0 ;
31205 int arg2 ;
31206 int result;
31207 PyObject * obj0 = 0 ;
31208 PyObject * obj1 = 0 ;
31209 char *kwnames[] = {
31210 (char *) "self",(char *) "orientation", NULL
31211 };
31212
31213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31215 if (SWIG_arg_fail(1)) SWIG_fail;
31216 {
31217 arg2 = (int)(SWIG_As_int(obj1));
31218 if (SWIG_arg_fail(2)) SWIG_fail;
31219 }
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31223
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 {
31228 resultobj = SWIG_From_int((int)(result));
31229 }
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31237 PyObject *resultobj;
31238 wxWindow *arg1 = (wxWindow *) 0 ;
31239 int arg2 ;
31240 int arg3 ;
31241 wxRect *arg4 = (wxRect *) NULL ;
31242 PyObject * obj0 = 0 ;
31243 PyObject * obj1 = 0 ;
31244 PyObject * obj2 = 0 ;
31245 PyObject * obj3 = 0 ;
31246 char *kwnames[] = {
31247 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31248 };
31249
31250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31252 if (SWIG_arg_fail(1)) SWIG_fail;
31253 {
31254 arg2 = (int)(SWIG_As_int(obj1));
31255 if (SWIG_arg_fail(2)) SWIG_fail;
31256 }
31257 {
31258 arg3 = (int)(SWIG_As_int(obj2));
31259 if (SWIG_arg_fail(3)) SWIG_fail;
31260 }
31261 if (obj3) {
31262 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31263 if (SWIG_arg_fail(4)) SWIG_fail;
31264 }
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31268
31269 wxPyEndAllowThreads(__tstate);
31270 if (PyErr_Occurred()) SWIG_fail;
31271 }
31272 Py_INCREF(Py_None); resultobj = Py_None;
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31280 PyObject *resultobj;
31281 wxWindow *arg1 = (wxWindow *) 0 ;
31282 int arg2 ;
31283 bool result;
31284 PyObject * obj0 = 0 ;
31285 PyObject * obj1 = 0 ;
31286 char *kwnames[] = {
31287 (char *) "self",(char *) "lines", NULL
31288 };
31289
31290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31292 if (SWIG_arg_fail(1)) SWIG_fail;
31293 {
31294 arg2 = (int)(SWIG_As_int(obj1));
31295 if (SWIG_arg_fail(2)) SWIG_fail;
31296 }
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = (bool)(arg1)->ScrollLines(arg2);
31300
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 {
31305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31306 }
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31314 PyObject *resultobj;
31315 wxWindow *arg1 = (wxWindow *) 0 ;
31316 int arg2 ;
31317 bool result;
31318 PyObject * obj0 = 0 ;
31319 PyObject * obj1 = 0 ;
31320 char *kwnames[] = {
31321 (char *) "self",(char *) "pages", NULL
31322 };
31323
31324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31326 if (SWIG_arg_fail(1)) SWIG_fail;
31327 {
31328 arg2 = (int)(SWIG_As_int(obj1));
31329 if (SWIG_arg_fail(2)) SWIG_fail;
31330 }
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 result = (bool)(arg1)->ScrollPages(arg2);
31334
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 {
31339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31340 }
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31348 PyObject *resultobj;
31349 wxWindow *arg1 = (wxWindow *) 0 ;
31350 bool result;
31351 PyObject * obj0 = 0 ;
31352 char *kwnames[] = {
31353 (char *) "self", NULL
31354 };
31355
31356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(1)) SWIG_fail;
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 result = (bool)(arg1)->LineUp();
31362
31363 wxPyEndAllowThreads(__tstate);
31364 if (PyErr_Occurred()) SWIG_fail;
31365 }
31366 {
31367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31368 }
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31376 PyObject *resultobj;
31377 wxWindow *arg1 = (wxWindow *) 0 ;
31378 bool result;
31379 PyObject * obj0 = 0 ;
31380 char *kwnames[] = {
31381 (char *) "self", NULL
31382 };
31383
31384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31386 if (SWIG_arg_fail(1)) SWIG_fail;
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 result = (bool)(arg1)->LineDown();
31390
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 {
31395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31396 }
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31404 PyObject *resultobj;
31405 wxWindow *arg1 = (wxWindow *) 0 ;
31406 bool result;
31407 PyObject * obj0 = 0 ;
31408 char *kwnames[] = {
31409 (char *) "self", NULL
31410 };
31411
31412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31414 if (SWIG_arg_fail(1)) SWIG_fail;
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = (bool)(arg1)->PageUp();
31418
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 {
31423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31424 }
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 bool result;
31435 PyObject * obj0 = 0 ;
31436 char *kwnames[] = {
31437 (char *) "self", NULL
31438 };
31439
31440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31442 if (SWIG_arg_fail(1)) SWIG_fail;
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (bool)(arg1)->PageDown();
31446
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 {
31451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31452 }
31453 return resultobj;
31454 fail:
31455 return NULL;
31456 }
31457
31458
31459 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj;
31461 wxWindow *arg1 = (wxWindow *) 0 ;
31462 wxString *arg2 = 0 ;
31463 bool temp2 = false ;
31464 PyObject * obj0 = 0 ;
31465 PyObject * obj1 = 0 ;
31466 char *kwnames[] = {
31467 (char *) "self",(char *) "text", NULL
31468 };
31469
31470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31472 if (SWIG_arg_fail(1)) SWIG_fail;
31473 {
31474 arg2 = wxString_in_helper(obj1);
31475 if (arg2 == NULL) SWIG_fail;
31476 temp2 = true;
31477 }
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 (arg1)->SetHelpText((wxString const &)*arg2);
31481
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 Py_INCREF(Py_None); resultobj = Py_None;
31486 {
31487 if (temp2)
31488 delete arg2;
31489 }
31490 return resultobj;
31491 fail:
31492 {
31493 if (temp2)
31494 delete arg2;
31495 }
31496 return NULL;
31497 }
31498
31499
31500 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31501 PyObject *resultobj;
31502 wxWindow *arg1 = (wxWindow *) 0 ;
31503 wxString *arg2 = 0 ;
31504 bool temp2 = false ;
31505 PyObject * obj0 = 0 ;
31506 PyObject * obj1 = 0 ;
31507 char *kwnames[] = {
31508 (char *) "self",(char *) "text", NULL
31509 };
31510
31511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31513 if (SWIG_arg_fail(1)) SWIG_fail;
31514 {
31515 arg2 = wxString_in_helper(obj1);
31516 if (arg2 == NULL) SWIG_fail;
31517 temp2 = true;
31518 }
31519 {
31520 PyThreadState* __tstate = wxPyBeginAllowThreads();
31521 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31522
31523 wxPyEndAllowThreads(__tstate);
31524 if (PyErr_Occurred()) SWIG_fail;
31525 }
31526 Py_INCREF(Py_None); resultobj = Py_None;
31527 {
31528 if (temp2)
31529 delete arg2;
31530 }
31531 return resultobj;
31532 fail:
31533 {
31534 if (temp2)
31535 delete arg2;
31536 }
31537 return NULL;
31538 }
31539
31540
31541 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 wxString result;
31545 PyObject * obj0 = 0 ;
31546 char *kwnames[] = {
31547 (char *) "self", NULL
31548 };
31549
31550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31552 if (SWIG_arg_fail(1)) SWIG_fail;
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = ((wxWindow const *)arg1)->GetHelpText();
31556
31557 wxPyEndAllowThreads(__tstate);
31558 if (PyErr_Occurred()) SWIG_fail;
31559 }
31560 {
31561 #if wxUSE_UNICODE
31562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31563 #else
31564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31565 #endif
31566 }
31567 return resultobj;
31568 fail:
31569 return NULL;
31570 }
31571
31572
31573 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31574 PyObject *resultobj;
31575 wxWindow *arg1 = (wxWindow *) 0 ;
31576 wxString *arg2 = 0 ;
31577 bool temp2 = false ;
31578 PyObject * obj0 = 0 ;
31579 PyObject * obj1 = 0 ;
31580 char *kwnames[] = {
31581 (char *) "self",(char *) "tip", NULL
31582 };
31583
31584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31586 if (SWIG_arg_fail(1)) SWIG_fail;
31587 {
31588 arg2 = wxString_in_helper(obj1);
31589 if (arg2 == NULL) SWIG_fail;
31590 temp2 = true;
31591 }
31592 {
31593 PyThreadState* __tstate = wxPyBeginAllowThreads();
31594 (arg1)->SetToolTip((wxString const &)*arg2);
31595
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 Py_INCREF(Py_None); resultobj = Py_None;
31600 {
31601 if (temp2)
31602 delete arg2;
31603 }
31604 return resultobj;
31605 fail:
31606 {
31607 if (temp2)
31608 delete arg2;
31609 }
31610 return NULL;
31611 }
31612
31613
31614 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj;
31616 wxWindow *arg1 = (wxWindow *) 0 ;
31617 wxToolTip *arg2 = (wxToolTip *) 0 ;
31618 PyObject * obj0 = 0 ;
31619 PyObject * obj1 = 0 ;
31620 char *kwnames[] = {
31621 (char *) "self",(char *) "tip", NULL
31622 };
31623
31624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31626 if (SWIG_arg_fail(1)) SWIG_fail;
31627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31628 if (SWIG_arg_fail(2)) SWIG_fail;
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 (arg1)->SetToolTip(arg2);
31632
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 Py_INCREF(Py_None); resultobj = Py_None;
31637 return resultobj;
31638 fail:
31639 return NULL;
31640 }
31641
31642
31643 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31644 PyObject *resultobj;
31645 wxWindow *arg1 = (wxWindow *) 0 ;
31646 wxToolTip *result;
31647 PyObject * obj0 = 0 ;
31648 char *kwnames[] = {
31649 (char *) "self", NULL
31650 };
31651
31652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31654 if (SWIG_arg_fail(1)) SWIG_fail;
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31658
31659 wxPyEndAllowThreads(__tstate);
31660 if (PyErr_Occurred()) SWIG_fail;
31661 }
31662 {
31663 resultobj = wxPyMake_wxObject(result, 0);
31664 }
31665 return resultobj;
31666 fail:
31667 return NULL;
31668 }
31669
31670
31671 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31672 PyObject *resultobj;
31673 wxWindow *arg1 = (wxWindow *) 0 ;
31674 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31675 PyObject * obj0 = 0 ;
31676 PyObject * obj1 = 0 ;
31677 char *kwnames[] = {
31678 (char *) "self",(char *) "dropTarget", NULL
31679 };
31680
31681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31683 if (SWIG_arg_fail(1)) SWIG_fail;
31684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31685 if (SWIG_arg_fail(2)) SWIG_fail;
31686 {
31687 PyThreadState* __tstate = wxPyBeginAllowThreads();
31688 (arg1)->SetDropTarget(arg2);
31689
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 Py_INCREF(Py_None); resultobj = Py_None;
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj;
31702 wxWindow *arg1 = (wxWindow *) 0 ;
31703 wxPyDropTarget *result;
31704 PyObject * obj0 = 0 ;
31705 char *kwnames[] = {
31706 (char *) "self", NULL
31707 };
31708
31709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31711 if (SWIG_arg_fail(1)) SWIG_fail;
31712 {
31713 PyThreadState* __tstate = wxPyBeginAllowThreads();
31714 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31715
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31727 PyObject *resultobj;
31728 wxWindow *arg1 = (wxWindow *) 0 ;
31729 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31730 PyObject * obj0 = 0 ;
31731 PyObject * obj1 = 0 ;
31732 char *kwnames[] = {
31733 (char *) "self",(char *) "constraints", NULL
31734 };
31735
31736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31738 if (SWIG_arg_fail(1)) SWIG_fail;
31739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31740 if (SWIG_arg_fail(2)) SWIG_fail;
31741 {
31742 PyThreadState* __tstate = wxPyBeginAllowThreads();
31743 (arg1)->SetConstraints(arg2);
31744
31745 wxPyEndAllowThreads(__tstate);
31746 if (PyErr_Occurred()) SWIG_fail;
31747 }
31748 Py_INCREF(Py_None); resultobj = Py_None;
31749 return resultobj;
31750 fail:
31751 return NULL;
31752 }
31753
31754
31755 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31756 PyObject *resultobj;
31757 wxWindow *arg1 = (wxWindow *) 0 ;
31758 wxLayoutConstraints *result;
31759 PyObject * obj0 = 0 ;
31760 char *kwnames[] = {
31761 (char *) "self", NULL
31762 };
31763
31764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31766 if (SWIG_arg_fail(1)) SWIG_fail;
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31770
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31782 PyObject *resultobj;
31783 wxWindow *arg1 = (wxWindow *) 0 ;
31784 bool arg2 ;
31785 PyObject * obj0 = 0 ;
31786 PyObject * obj1 = 0 ;
31787 char *kwnames[] = {
31788 (char *) "self",(char *) "autoLayout", NULL
31789 };
31790
31791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31793 if (SWIG_arg_fail(1)) SWIG_fail;
31794 {
31795 arg2 = (bool)(SWIG_As_bool(obj1));
31796 if (SWIG_arg_fail(2)) SWIG_fail;
31797 }
31798 {
31799 PyThreadState* __tstate = wxPyBeginAllowThreads();
31800 (arg1)->SetAutoLayout(arg2);
31801
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 Py_INCREF(Py_None); resultobj = Py_None;
31806 return resultobj;
31807 fail:
31808 return NULL;
31809 }
31810
31811
31812 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31813 PyObject *resultobj;
31814 wxWindow *arg1 = (wxWindow *) 0 ;
31815 bool result;
31816 PyObject * obj0 = 0 ;
31817 char *kwnames[] = {
31818 (char *) "self", NULL
31819 };
31820
31821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31823 if (SWIG_arg_fail(1)) SWIG_fail;
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31827
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 {
31832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31833 }
31834 return resultobj;
31835 fail:
31836 return NULL;
31837 }
31838
31839
31840 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31841 PyObject *resultobj;
31842 wxWindow *arg1 = (wxWindow *) 0 ;
31843 bool result;
31844 PyObject * obj0 = 0 ;
31845 char *kwnames[] = {
31846 (char *) "self", NULL
31847 };
31848
31849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31851 if (SWIG_arg_fail(1)) SWIG_fail;
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = (bool)(arg1)->Layout();
31855
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 {
31860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31861 }
31862 return resultobj;
31863 fail:
31864 return NULL;
31865 }
31866
31867
31868 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31869 PyObject *resultobj;
31870 wxWindow *arg1 = (wxWindow *) 0 ;
31871 wxSizer *arg2 = (wxSizer *) 0 ;
31872 bool arg3 = (bool) true ;
31873 PyObject * obj0 = 0 ;
31874 PyObject * obj1 = 0 ;
31875 PyObject * obj2 = 0 ;
31876 char *kwnames[] = {
31877 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31878 };
31879
31880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31882 if (SWIG_arg_fail(1)) SWIG_fail;
31883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31884 if (SWIG_arg_fail(2)) SWIG_fail;
31885 if (obj2) {
31886 {
31887 arg3 = (bool)(SWIG_As_bool(obj2));
31888 if (SWIG_arg_fail(3)) SWIG_fail;
31889 }
31890 }
31891 {
31892 PyThreadState* __tstate = wxPyBeginAllowThreads();
31893 (arg1)->SetSizer(arg2,arg3);
31894
31895 wxPyEndAllowThreads(__tstate);
31896 if (PyErr_Occurred()) SWIG_fail;
31897 }
31898 Py_INCREF(Py_None); resultobj = Py_None;
31899 return resultobj;
31900 fail:
31901 return NULL;
31902 }
31903
31904
31905 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31906 PyObject *resultobj;
31907 wxWindow *arg1 = (wxWindow *) 0 ;
31908 wxSizer *arg2 = (wxSizer *) 0 ;
31909 bool arg3 = (bool) true ;
31910 PyObject * obj0 = 0 ;
31911 PyObject * obj1 = 0 ;
31912 PyObject * obj2 = 0 ;
31913 char *kwnames[] = {
31914 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31915 };
31916
31917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31919 if (SWIG_arg_fail(1)) SWIG_fail;
31920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31921 if (SWIG_arg_fail(2)) SWIG_fail;
31922 if (obj2) {
31923 {
31924 arg3 = (bool)(SWIG_As_bool(obj2));
31925 if (SWIG_arg_fail(3)) SWIG_fail;
31926 }
31927 }
31928 {
31929 PyThreadState* __tstate = wxPyBeginAllowThreads();
31930 (arg1)->SetSizerAndFit(arg2,arg3);
31931
31932 wxPyEndAllowThreads(__tstate);
31933 if (PyErr_Occurred()) SWIG_fail;
31934 }
31935 Py_INCREF(Py_None); resultobj = Py_None;
31936 return resultobj;
31937 fail:
31938 return NULL;
31939 }
31940
31941
31942 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31943 PyObject *resultobj;
31944 wxWindow *arg1 = (wxWindow *) 0 ;
31945 wxSizer *result;
31946 PyObject * obj0 = 0 ;
31947 char *kwnames[] = {
31948 (char *) "self", NULL
31949 };
31950
31951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31953 if (SWIG_arg_fail(1)) SWIG_fail;
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31957
31958 wxPyEndAllowThreads(__tstate);
31959 if (PyErr_Occurred()) SWIG_fail;
31960 }
31961 {
31962 resultobj = wxPyMake_wxSizer(result, 0);
31963 }
31964 return resultobj;
31965 fail:
31966 return NULL;
31967 }
31968
31969
31970 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31971 PyObject *resultobj;
31972 wxWindow *arg1 = (wxWindow *) 0 ;
31973 wxSizer *arg2 = (wxSizer *) 0 ;
31974 PyObject * obj0 = 0 ;
31975 PyObject * obj1 = 0 ;
31976 char *kwnames[] = {
31977 (char *) "self",(char *) "sizer", NULL
31978 };
31979
31980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31982 if (SWIG_arg_fail(1)) SWIG_fail;
31983 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(2)) SWIG_fail;
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 (arg1)->SetContainingSizer(arg2);
31988
31989 wxPyEndAllowThreads(__tstate);
31990 if (PyErr_Occurred()) SWIG_fail;
31991 }
31992 Py_INCREF(Py_None); resultobj = Py_None;
31993 return resultobj;
31994 fail:
31995 return NULL;
31996 }
31997
31998
31999 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32000 PyObject *resultobj;
32001 wxWindow *arg1 = (wxWindow *) 0 ;
32002 wxSizer *result;
32003 PyObject * obj0 = 0 ;
32004 char *kwnames[] = {
32005 (char *) "self", NULL
32006 };
32007
32008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32010 if (SWIG_arg_fail(1)) SWIG_fail;
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32014
32015 wxPyEndAllowThreads(__tstate);
32016 if (PyErr_Occurred()) SWIG_fail;
32017 }
32018 {
32019 resultobj = wxPyMake_wxSizer(result, 0);
32020 }
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32028 PyObject *resultobj;
32029 wxWindow *arg1 = (wxWindow *) 0 ;
32030 PyObject * obj0 = 0 ;
32031 char *kwnames[] = {
32032 (char *) "self", NULL
32033 };
32034
32035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32037 if (SWIG_arg_fail(1)) SWIG_fail;
32038 {
32039 PyThreadState* __tstate = wxPyBeginAllowThreads();
32040 (arg1)->InheritAttributes();
32041
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 Py_INCREF(Py_None); resultobj = Py_None;
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32053 PyObject *resultobj;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 bool result;
32056 PyObject * obj0 = 0 ;
32057 char *kwnames[] = {
32058 (char *) "self", NULL
32059 };
32060
32061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32063 if (SWIG_arg_fail(1)) SWIG_fail;
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32067
32068 wxPyEndAllowThreads(__tstate);
32069 if (PyErr_Occurred()) SWIG_fail;
32070 }
32071 {
32072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32073 }
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32081 PyObject *obj;
32082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32083 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32084 Py_INCREF(obj);
32085 return Py_BuildValue((char *)"");
32086 }
32087 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj;
32089 long arg1 ;
32090 wxWindow *arg2 = (wxWindow *) NULL ;
32091 wxWindow *result;
32092 PyObject * obj0 = 0 ;
32093 PyObject * obj1 = 0 ;
32094 char *kwnames[] = {
32095 (char *) "id",(char *) "parent", NULL
32096 };
32097
32098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32099 {
32100 arg1 = (long)(SWIG_As_long(obj0));
32101 if (SWIG_arg_fail(1)) SWIG_fail;
32102 }
32103 if (obj1) {
32104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32105 if (SWIG_arg_fail(2)) SWIG_fail;
32106 }
32107 {
32108 if (!wxPyCheckForApp()) SWIG_fail;
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32111
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 {
32116 resultobj = wxPyMake_wxObject(result, 0);
32117 }
32118 return resultobj;
32119 fail:
32120 return NULL;
32121 }
32122
32123
32124 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32125 PyObject *resultobj;
32126 wxString *arg1 = 0 ;
32127 wxWindow *arg2 = (wxWindow *) NULL ;
32128 wxWindow *result;
32129 bool temp1 = false ;
32130 PyObject * obj0 = 0 ;
32131 PyObject * obj1 = 0 ;
32132 char *kwnames[] = {
32133 (char *) "name",(char *) "parent", NULL
32134 };
32135
32136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32137 {
32138 arg1 = wxString_in_helper(obj0);
32139 if (arg1 == NULL) SWIG_fail;
32140 temp1 = true;
32141 }
32142 if (obj1) {
32143 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32144 if (SWIG_arg_fail(2)) SWIG_fail;
32145 }
32146 {
32147 if (!wxPyCheckForApp()) SWIG_fail;
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32150
32151 wxPyEndAllowThreads(__tstate);
32152 if (PyErr_Occurred()) SWIG_fail;
32153 }
32154 {
32155 resultobj = wxPyMake_wxObject(result, 0);
32156 }
32157 {
32158 if (temp1)
32159 delete arg1;
32160 }
32161 return resultobj;
32162 fail:
32163 {
32164 if (temp1)
32165 delete arg1;
32166 }
32167 return NULL;
32168 }
32169
32170
32171 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32172 PyObject *resultobj;
32173 wxString *arg1 = 0 ;
32174 wxWindow *arg2 = (wxWindow *) NULL ;
32175 wxWindow *result;
32176 bool temp1 = false ;
32177 PyObject * obj0 = 0 ;
32178 PyObject * obj1 = 0 ;
32179 char *kwnames[] = {
32180 (char *) "label",(char *) "parent", NULL
32181 };
32182
32183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32184 {
32185 arg1 = wxString_in_helper(obj0);
32186 if (arg1 == NULL) SWIG_fail;
32187 temp1 = true;
32188 }
32189 if (obj1) {
32190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32191 if (SWIG_arg_fail(2)) SWIG_fail;
32192 }
32193 {
32194 if (!wxPyCheckForApp()) SWIG_fail;
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32197
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 {
32202 resultobj = wxPyMake_wxObject(result, 0);
32203 }
32204 {
32205 if (temp1)
32206 delete arg1;
32207 }
32208 return resultobj;
32209 fail:
32210 {
32211 if (temp1)
32212 delete arg1;
32213 }
32214 return NULL;
32215 }
32216
32217
32218 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj;
32220 wxWindow *arg1 = (wxWindow *) 0 ;
32221 unsigned long arg2 ;
32222 wxWindow *result;
32223 PyObject * obj0 = 0 ;
32224 PyObject * obj1 = 0 ;
32225 char *kwnames[] = {
32226 (char *) "parent",(char *) "_hWnd", NULL
32227 };
32228
32229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32231 if (SWIG_arg_fail(1)) SWIG_fail;
32232 {
32233 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32234 if (SWIG_arg_fail(2)) SWIG_fail;
32235 }
32236 {
32237 PyThreadState* __tstate = wxPyBeginAllowThreads();
32238 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32239
32240 wxPyEndAllowThreads(__tstate);
32241 if (PyErr_Occurred()) SWIG_fail;
32242 }
32243 {
32244 resultobj = wxPyMake_wxObject(result, 0);
32245 }
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32253 PyObject *resultobj;
32254 PyObject *result;
32255 char *kwnames[] = {
32256 NULL
32257 };
32258
32259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 result = (PyObject *)GetTopLevelWindows();
32263
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 resultobj = result;
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32275 PyObject *resultobj;
32276 wxValidator *result;
32277 char *kwnames[] = {
32278 NULL
32279 };
32280
32281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32282 {
32283 PyThreadState* __tstate = wxPyBeginAllowThreads();
32284 result = (wxValidator *)new wxValidator();
32285
32286 wxPyEndAllowThreads(__tstate);
32287 if (PyErr_Occurred()) SWIG_fail;
32288 }
32289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32290 return resultobj;
32291 fail:
32292 return NULL;
32293 }
32294
32295
32296 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32297 PyObject *resultobj;
32298 wxValidator *arg1 = (wxValidator *) 0 ;
32299 wxValidator *result;
32300 PyObject * obj0 = 0 ;
32301 char *kwnames[] = {
32302 (char *) "self", NULL
32303 };
32304
32305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32307 if (SWIG_arg_fail(1)) SWIG_fail;
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 result = (wxValidator *)(arg1)->Clone();
32311
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 {
32316 resultobj = wxPyMake_wxObject(result, 0);
32317 }
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj;
32326 wxValidator *arg1 = (wxValidator *) 0 ;
32327 wxWindow *arg2 = (wxWindow *) 0 ;
32328 bool result;
32329 PyObject * obj0 = 0 ;
32330 PyObject * obj1 = 0 ;
32331 char *kwnames[] = {
32332 (char *) "self",(char *) "parent", NULL
32333 };
32334
32335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32337 if (SWIG_arg_fail(1)) SWIG_fail;
32338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32339 if (SWIG_arg_fail(2)) SWIG_fail;
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 result = (bool)(arg1)->Validate(arg2);
32343
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32349 }
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj;
32358 wxValidator *arg1 = (wxValidator *) 0 ;
32359 bool result;
32360 PyObject * obj0 = 0 ;
32361 char *kwnames[] = {
32362 (char *) "self", NULL
32363 };
32364
32365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32367 if (SWIG_arg_fail(1)) SWIG_fail;
32368 {
32369 PyThreadState* __tstate = wxPyBeginAllowThreads();
32370 result = (bool)(arg1)->TransferToWindow();
32371
32372 wxPyEndAllowThreads(__tstate);
32373 if (PyErr_Occurred()) SWIG_fail;
32374 }
32375 {
32376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32377 }
32378 return resultobj;
32379 fail:
32380 return NULL;
32381 }
32382
32383
32384 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32385 PyObject *resultobj;
32386 wxValidator *arg1 = (wxValidator *) 0 ;
32387 bool result;
32388 PyObject * obj0 = 0 ;
32389 char *kwnames[] = {
32390 (char *) "self", NULL
32391 };
32392
32393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32395 if (SWIG_arg_fail(1)) SWIG_fail;
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 result = (bool)(arg1)->TransferFromWindow();
32399
32400 wxPyEndAllowThreads(__tstate);
32401 if (PyErr_Occurred()) SWIG_fail;
32402 }
32403 {
32404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32405 }
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj;
32414 wxValidator *arg1 = (wxValidator *) 0 ;
32415 wxWindow *result;
32416 PyObject * obj0 = 0 ;
32417 char *kwnames[] = {
32418 (char *) "self", NULL
32419 };
32420
32421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32423 if (SWIG_arg_fail(1)) SWIG_fail;
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (wxWindow *)(arg1)->GetWindow();
32427
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 {
32432 resultobj = wxPyMake_wxObject(result, 0);
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32441 PyObject *resultobj;
32442 wxValidator *arg1 = (wxValidator *) 0 ;
32443 wxWindow *arg2 = (wxWindow *) 0 ;
32444 PyObject * obj0 = 0 ;
32445 PyObject * obj1 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "self",(char *) "window", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32452 if (SWIG_arg_fail(1)) SWIG_fail;
32453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32454 if (SWIG_arg_fail(2)) SWIG_fail;
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 (arg1)->SetWindow(arg2);
32458
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 Py_INCREF(Py_None); resultobj = Py_None;
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj;
32471 bool result;
32472 char *kwnames[] = {
32473 NULL
32474 };
32475
32476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 result = (bool)wxValidator::IsSilent();
32480
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 {
32485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32486 }
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32494 PyObject *resultobj;
32495 int arg1 = (int) true ;
32496 PyObject * obj0 = 0 ;
32497 char *kwnames[] = {
32498 (char *) "doIt", NULL
32499 };
32500
32501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32502 if (obj0) {
32503 {
32504 arg1 = (int)(SWIG_As_int(obj0));
32505 if (SWIG_arg_fail(1)) SWIG_fail;
32506 }
32507 }
32508 {
32509 PyThreadState* __tstate = wxPyBeginAllowThreads();
32510 wxValidator::SetBellOnError(arg1);
32511
32512 wxPyEndAllowThreads(__tstate);
32513 if (PyErr_Occurred()) SWIG_fail;
32514 }
32515 Py_INCREF(Py_None); resultobj = Py_None;
32516 return resultobj;
32517 fail:
32518 return NULL;
32519 }
32520
32521
32522 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32523 PyObject *obj;
32524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32525 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32526 Py_INCREF(obj);
32527 return Py_BuildValue((char *)"");
32528 }
32529 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32530 PyObject *resultobj;
32531 wxPyValidator *result;
32532 char *kwnames[] = {
32533 NULL
32534 };
32535
32536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 result = (wxPyValidator *)new wxPyValidator();
32540
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj;
32553 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32554 PyObject *arg2 = (PyObject *) 0 ;
32555 PyObject *arg3 = (PyObject *) 0 ;
32556 int arg4 = (int) true ;
32557 PyObject * obj0 = 0 ;
32558 PyObject * obj1 = 0 ;
32559 PyObject * obj2 = 0 ;
32560 PyObject * obj3 = 0 ;
32561 char *kwnames[] = {
32562 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32563 };
32564
32565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32567 if (SWIG_arg_fail(1)) SWIG_fail;
32568 arg2 = obj1;
32569 arg3 = obj2;
32570 if (obj3) {
32571 {
32572 arg4 = (int)(SWIG_As_int(obj3));
32573 if (SWIG_arg_fail(4)) SWIG_fail;
32574 }
32575 }
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 Py_INCREF(Py_None); resultobj = Py_None;
32584 return resultobj;
32585 fail:
32586 return NULL;
32587 }
32588
32589
32590 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32591 PyObject *obj;
32592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32593 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32594 Py_INCREF(obj);
32595 return Py_BuildValue((char *)"");
32596 }
32597 static int _wrap_DefaultValidator_set(PyObject *) {
32598 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32599 return 1;
32600 }
32601
32602
32603 static PyObject *_wrap_DefaultValidator_get(void) {
32604 PyObject *pyobj;
32605
32606 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32607 return pyobj;
32608 }
32609
32610
32611 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32612 PyObject *resultobj;
32613 wxString const &arg1_defvalue = wxPyEmptyString ;
32614 wxString *arg1 = (wxString *) &arg1_defvalue ;
32615 long arg2 = (long) 0 ;
32616 wxMenu *result;
32617 bool temp1 = false ;
32618 PyObject * obj0 = 0 ;
32619 PyObject * obj1 = 0 ;
32620 char *kwnames[] = {
32621 (char *) "title",(char *) "style", NULL
32622 };
32623
32624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32625 if (obj0) {
32626 {
32627 arg1 = wxString_in_helper(obj0);
32628 if (arg1 == NULL) SWIG_fail;
32629 temp1 = true;
32630 }
32631 }
32632 if (obj1) {
32633 {
32634 arg2 = (long)(SWIG_As_long(obj1));
32635 if (SWIG_arg_fail(2)) SWIG_fail;
32636 }
32637 }
32638 {
32639 if (!wxPyCheckForApp()) SWIG_fail;
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32642
32643 wxPyEndAllowThreads(__tstate);
32644 if (PyErr_Occurred()) SWIG_fail;
32645 }
32646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32647 {
32648 if (temp1)
32649 delete arg1;
32650 }
32651 return resultobj;
32652 fail:
32653 {
32654 if (temp1)
32655 delete arg1;
32656 }
32657 return NULL;
32658 }
32659
32660
32661 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxMenu *arg1 = (wxMenu *) 0 ;
32664 int arg2 ;
32665 wxString *arg3 = 0 ;
32666 wxString const &arg4_defvalue = wxPyEmptyString ;
32667 wxString *arg4 = (wxString *) &arg4_defvalue ;
32668 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32669 wxMenuItem *result;
32670 bool temp3 = false ;
32671 bool temp4 = false ;
32672 PyObject * obj0 = 0 ;
32673 PyObject * obj1 = 0 ;
32674 PyObject * obj2 = 0 ;
32675 PyObject * obj3 = 0 ;
32676 PyObject * obj4 = 0 ;
32677 char *kwnames[] = {
32678 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32679 };
32680
32681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32683 if (SWIG_arg_fail(1)) SWIG_fail;
32684 {
32685 arg2 = (int)(SWIG_As_int(obj1));
32686 if (SWIG_arg_fail(2)) SWIG_fail;
32687 }
32688 {
32689 arg3 = wxString_in_helper(obj2);
32690 if (arg3 == NULL) SWIG_fail;
32691 temp3 = true;
32692 }
32693 if (obj3) {
32694 {
32695 arg4 = wxString_in_helper(obj3);
32696 if (arg4 == NULL) SWIG_fail;
32697 temp4 = true;
32698 }
32699 }
32700 if (obj4) {
32701 {
32702 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32703 if (SWIG_arg_fail(5)) SWIG_fail;
32704 }
32705 }
32706 {
32707 PyThreadState* __tstate = wxPyBeginAllowThreads();
32708 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32709
32710 wxPyEndAllowThreads(__tstate);
32711 if (PyErr_Occurred()) SWIG_fail;
32712 }
32713 {
32714 resultobj = wxPyMake_wxObject(result, 0);
32715 }
32716 {
32717 if (temp3)
32718 delete arg3;
32719 }
32720 {
32721 if (temp4)
32722 delete arg4;
32723 }
32724 return resultobj;
32725 fail:
32726 {
32727 if (temp3)
32728 delete arg3;
32729 }
32730 {
32731 if (temp4)
32732 delete arg4;
32733 }
32734 return NULL;
32735 }
32736
32737
32738 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32739 PyObject *resultobj;
32740 wxMenu *arg1 = (wxMenu *) 0 ;
32741 wxMenuItem *result;
32742 PyObject * obj0 = 0 ;
32743 char *kwnames[] = {
32744 (char *) "self", NULL
32745 };
32746
32747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32749 if (SWIG_arg_fail(1)) SWIG_fail;
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 result = (wxMenuItem *)(arg1)->AppendSeparator();
32753
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 {
32758 resultobj = wxPyMake_wxObject(result, 0);
32759 }
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32767 PyObject *resultobj;
32768 wxMenu *arg1 = (wxMenu *) 0 ;
32769 int arg2 ;
32770 wxString *arg3 = 0 ;
32771 wxString const &arg4_defvalue = wxPyEmptyString ;
32772 wxString *arg4 = (wxString *) &arg4_defvalue ;
32773 wxMenuItem *result;
32774 bool temp3 = false ;
32775 bool temp4 = false ;
32776 PyObject * obj0 = 0 ;
32777 PyObject * obj1 = 0 ;
32778 PyObject * obj2 = 0 ;
32779 PyObject * obj3 = 0 ;
32780 char *kwnames[] = {
32781 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32782 };
32783
32784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32786 if (SWIG_arg_fail(1)) SWIG_fail;
32787 {
32788 arg2 = (int)(SWIG_As_int(obj1));
32789 if (SWIG_arg_fail(2)) SWIG_fail;
32790 }
32791 {
32792 arg3 = wxString_in_helper(obj2);
32793 if (arg3 == NULL) SWIG_fail;
32794 temp3 = true;
32795 }
32796 if (obj3) {
32797 {
32798 arg4 = wxString_in_helper(obj3);
32799 if (arg4 == NULL) SWIG_fail;
32800 temp4 = true;
32801 }
32802 }
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32806
32807 wxPyEndAllowThreads(__tstate);
32808 if (PyErr_Occurred()) SWIG_fail;
32809 }
32810 {
32811 resultobj = wxPyMake_wxObject(result, 0);
32812 }
32813 {
32814 if (temp3)
32815 delete arg3;
32816 }
32817 {
32818 if (temp4)
32819 delete arg4;
32820 }
32821 return resultobj;
32822 fail:
32823 {
32824 if (temp3)
32825 delete arg3;
32826 }
32827 {
32828 if (temp4)
32829 delete arg4;
32830 }
32831 return NULL;
32832 }
32833
32834
32835 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj;
32837 wxMenu *arg1 = (wxMenu *) 0 ;
32838 int arg2 ;
32839 wxString *arg3 = 0 ;
32840 wxString const &arg4_defvalue = wxPyEmptyString ;
32841 wxString *arg4 = (wxString *) &arg4_defvalue ;
32842 wxMenuItem *result;
32843 bool temp3 = false ;
32844 bool temp4 = false ;
32845 PyObject * obj0 = 0 ;
32846 PyObject * obj1 = 0 ;
32847 PyObject * obj2 = 0 ;
32848 PyObject * obj3 = 0 ;
32849 char *kwnames[] = {
32850 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32851 };
32852
32853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (int)(SWIG_As_int(obj1));
32858 if (SWIG_arg_fail(2)) SWIG_fail;
32859 }
32860 {
32861 arg3 = wxString_in_helper(obj2);
32862 if (arg3 == NULL) SWIG_fail;
32863 temp3 = true;
32864 }
32865 if (obj3) {
32866 {
32867 arg4 = wxString_in_helper(obj3);
32868 if (arg4 == NULL) SWIG_fail;
32869 temp4 = true;
32870 }
32871 }
32872 {
32873 PyThreadState* __tstate = wxPyBeginAllowThreads();
32874 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32875
32876 wxPyEndAllowThreads(__tstate);
32877 if (PyErr_Occurred()) SWIG_fail;
32878 }
32879 {
32880 resultobj = wxPyMake_wxObject(result, 0);
32881 }
32882 {
32883 if (temp3)
32884 delete arg3;
32885 }
32886 {
32887 if (temp4)
32888 delete arg4;
32889 }
32890 return resultobj;
32891 fail:
32892 {
32893 if (temp3)
32894 delete arg3;
32895 }
32896 {
32897 if (temp4)
32898 delete arg4;
32899 }
32900 return NULL;
32901 }
32902
32903
32904 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32905 PyObject *resultobj;
32906 wxMenu *arg1 = (wxMenu *) 0 ;
32907 int arg2 ;
32908 wxString *arg3 = 0 ;
32909 wxMenu *arg4 = (wxMenu *) 0 ;
32910 wxString const &arg5_defvalue = wxPyEmptyString ;
32911 wxString *arg5 = (wxString *) &arg5_defvalue ;
32912 wxMenuItem *result;
32913 bool temp3 = false ;
32914 bool temp5 = false ;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 PyObject * obj2 = 0 ;
32918 PyObject * obj3 = 0 ;
32919 PyObject * obj4 = 0 ;
32920 char *kwnames[] = {
32921 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32922 };
32923
32924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32926 if (SWIG_arg_fail(1)) SWIG_fail;
32927 {
32928 arg2 = (int)(SWIG_As_int(obj1));
32929 if (SWIG_arg_fail(2)) SWIG_fail;
32930 }
32931 {
32932 arg3 = wxString_in_helper(obj2);
32933 if (arg3 == NULL) SWIG_fail;
32934 temp3 = true;
32935 }
32936 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32937 if (SWIG_arg_fail(4)) SWIG_fail;
32938 if (obj4) {
32939 {
32940 arg5 = wxString_in_helper(obj4);
32941 if (arg5 == NULL) SWIG_fail;
32942 temp5 = true;
32943 }
32944 }
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32948
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 {
32953 resultobj = wxPyMake_wxObject(result, 0);
32954 }
32955 {
32956 if (temp3)
32957 delete arg3;
32958 }
32959 {
32960 if (temp5)
32961 delete arg5;
32962 }
32963 return resultobj;
32964 fail:
32965 {
32966 if (temp3)
32967 delete arg3;
32968 }
32969 {
32970 if (temp5)
32971 delete arg5;
32972 }
32973 return NULL;
32974 }
32975
32976
32977 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj;
32979 wxMenu *arg1 = (wxMenu *) 0 ;
32980 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32981 wxMenuItem *result;
32982 PyObject * obj0 = 0 ;
32983 PyObject * obj1 = 0 ;
32984 char *kwnames[] = {
32985 (char *) "self",(char *) "item", NULL
32986 };
32987
32988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32990 if (SWIG_arg_fail(1)) SWIG_fail;
32991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32992 if (SWIG_arg_fail(2)) SWIG_fail;
32993 {
32994 PyThreadState* __tstate = wxPyBeginAllowThreads();
32995 result = (wxMenuItem *)(arg1)->Append(arg2);
32996
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 {
33001 resultobj = wxPyMake_wxObject(result, 0);
33002 }
33003 return resultobj;
33004 fail:
33005 return NULL;
33006 }
33007
33008
33009 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33010 PyObject *resultobj;
33011 wxMenu *arg1 = (wxMenu *) 0 ;
33012 PyObject * obj0 = 0 ;
33013 char *kwnames[] = {
33014 (char *) "self", NULL
33015 };
33016
33017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33019 if (SWIG_arg_fail(1)) SWIG_fail;
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 (arg1)->Break();
33023
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 Py_INCREF(Py_None); resultobj = Py_None;
33028 return resultobj;
33029 fail:
33030 return NULL;
33031 }
33032
33033
33034 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33035 PyObject *resultobj;
33036 wxMenu *arg1 = (wxMenu *) 0 ;
33037 size_t arg2 ;
33038 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33039 wxMenuItem *result;
33040 PyObject * obj0 = 0 ;
33041 PyObject * obj1 = 0 ;
33042 PyObject * obj2 = 0 ;
33043 char *kwnames[] = {
33044 (char *) "self",(char *) "pos",(char *) "item", NULL
33045 };
33046
33047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33049 if (SWIG_arg_fail(1)) SWIG_fail;
33050 {
33051 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33052 if (SWIG_arg_fail(2)) SWIG_fail;
33053 }
33054 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33055 if (SWIG_arg_fail(3)) SWIG_fail;
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33059
33060 wxPyEndAllowThreads(__tstate);
33061 if (PyErr_Occurred()) SWIG_fail;
33062 }
33063 {
33064 resultobj = wxPyMake_wxObject(result, 0);
33065 }
33066 return resultobj;
33067 fail:
33068 return NULL;
33069 }
33070
33071
33072 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj;
33074 wxMenu *arg1 = (wxMenu *) 0 ;
33075 size_t arg2 ;
33076 int arg3 ;
33077 wxString *arg4 = 0 ;
33078 wxString const &arg5_defvalue = wxPyEmptyString ;
33079 wxString *arg5 = (wxString *) &arg5_defvalue ;
33080 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33081 wxMenuItem *result;
33082 bool temp4 = false ;
33083 bool temp5 = false ;
33084 PyObject * obj0 = 0 ;
33085 PyObject * obj1 = 0 ;
33086 PyObject * obj2 = 0 ;
33087 PyObject * obj3 = 0 ;
33088 PyObject * obj4 = 0 ;
33089 PyObject * obj5 = 0 ;
33090 char *kwnames[] = {
33091 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33092 };
33093
33094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33096 if (SWIG_arg_fail(1)) SWIG_fail;
33097 {
33098 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33099 if (SWIG_arg_fail(2)) SWIG_fail;
33100 }
33101 {
33102 arg3 = (int)(SWIG_As_int(obj2));
33103 if (SWIG_arg_fail(3)) SWIG_fail;
33104 }
33105 {
33106 arg4 = wxString_in_helper(obj3);
33107 if (arg4 == NULL) SWIG_fail;
33108 temp4 = true;
33109 }
33110 if (obj4) {
33111 {
33112 arg5 = wxString_in_helper(obj4);
33113 if (arg5 == NULL) SWIG_fail;
33114 temp5 = true;
33115 }
33116 }
33117 if (obj5) {
33118 {
33119 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33120 if (SWIG_arg_fail(6)) SWIG_fail;
33121 }
33122 }
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33126
33127 wxPyEndAllowThreads(__tstate);
33128 if (PyErr_Occurred()) SWIG_fail;
33129 }
33130 {
33131 resultobj = wxPyMake_wxObject(result, 0);
33132 }
33133 {
33134 if (temp4)
33135 delete arg4;
33136 }
33137 {
33138 if (temp5)
33139 delete arg5;
33140 }
33141 return resultobj;
33142 fail:
33143 {
33144 if (temp4)
33145 delete arg4;
33146 }
33147 {
33148 if (temp5)
33149 delete arg5;
33150 }
33151 return NULL;
33152 }
33153
33154
33155 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj;
33157 wxMenu *arg1 = (wxMenu *) 0 ;
33158 size_t arg2 ;
33159 wxMenuItem *result;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 char *kwnames[] = {
33163 (char *) "self",(char *) "pos", NULL
33164 };
33165
33166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(1)) SWIG_fail;
33169 {
33170 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33171 if (SWIG_arg_fail(2)) SWIG_fail;
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 {
33181 resultobj = wxPyMake_wxObject(result, 0);
33182 }
33183 return resultobj;
33184 fail:
33185 return NULL;
33186 }
33187
33188
33189 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33190 PyObject *resultobj;
33191 wxMenu *arg1 = (wxMenu *) 0 ;
33192 size_t arg2 ;
33193 int arg3 ;
33194 wxString *arg4 = 0 ;
33195 wxString const &arg5_defvalue = wxPyEmptyString ;
33196 wxString *arg5 = (wxString *) &arg5_defvalue ;
33197 wxMenuItem *result;
33198 bool temp4 = false ;
33199 bool temp5 = false ;
33200 PyObject * obj0 = 0 ;
33201 PyObject * obj1 = 0 ;
33202 PyObject * obj2 = 0 ;
33203 PyObject * obj3 = 0 ;
33204 PyObject * obj4 = 0 ;
33205 char *kwnames[] = {
33206 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33207 };
33208
33209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33211 if (SWIG_arg_fail(1)) SWIG_fail;
33212 {
33213 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33214 if (SWIG_arg_fail(2)) SWIG_fail;
33215 }
33216 {
33217 arg3 = (int)(SWIG_As_int(obj2));
33218 if (SWIG_arg_fail(3)) SWIG_fail;
33219 }
33220 {
33221 arg4 = wxString_in_helper(obj3);
33222 if (arg4 == NULL) SWIG_fail;
33223 temp4 = true;
33224 }
33225 if (obj4) {
33226 {
33227 arg5 = wxString_in_helper(obj4);
33228 if (arg5 == NULL) SWIG_fail;
33229 temp5 = true;
33230 }
33231 }
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33235
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 {
33240 resultobj = wxPyMake_wxObject(result, 0);
33241 }
33242 {
33243 if (temp4)
33244 delete arg4;
33245 }
33246 {
33247 if (temp5)
33248 delete arg5;
33249 }
33250 return resultobj;
33251 fail:
33252 {
33253 if (temp4)
33254 delete arg4;
33255 }
33256 {
33257 if (temp5)
33258 delete arg5;
33259 }
33260 return NULL;
33261 }
33262
33263
33264 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj;
33266 wxMenu *arg1 = (wxMenu *) 0 ;
33267 size_t arg2 ;
33268 int arg3 ;
33269 wxString *arg4 = 0 ;
33270 wxString const &arg5_defvalue = wxPyEmptyString ;
33271 wxString *arg5 = (wxString *) &arg5_defvalue ;
33272 wxMenuItem *result;
33273 bool temp4 = false ;
33274 bool temp5 = false ;
33275 PyObject * obj0 = 0 ;
33276 PyObject * obj1 = 0 ;
33277 PyObject * obj2 = 0 ;
33278 PyObject * obj3 = 0 ;
33279 PyObject * obj4 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 {
33288 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33289 if (SWIG_arg_fail(2)) SWIG_fail;
33290 }
33291 {
33292 arg3 = (int)(SWIG_As_int(obj2));
33293 if (SWIG_arg_fail(3)) SWIG_fail;
33294 }
33295 {
33296 arg4 = wxString_in_helper(obj3);
33297 if (arg4 == NULL) SWIG_fail;
33298 temp4 = true;
33299 }
33300 if (obj4) {
33301 {
33302 arg5 = wxString_in_helper(obj4);
33303 if (arg5 == NULL) SWIG_fail;
33304 temp5 = true;
33305 }
33306 }
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33310
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 {
33315 resultobj = wxPyMake_wxObject(result, 0);
33316 }
33317 {
33318 if (temp4)
33319 delete arg4;
33320 }
33321 {
33322 if (temp5)
33323 delete arg5;
33324 }
33325 return resultobj;
33326 fail:
33327 {
33328 if (temp4)
33329 delete arg4;
33330 }
33331 {
33332 if (temp5)
33333 delete arg5;
33334 }
33335 return NULL;
33336 }
33337
33338
33339 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33340 PyObject *resultobj;
33341 wxMenu *arg1 = (wxMenu *) 0 ;
33342 size_t arg2 ;
33343 int arg3 ;
33344 wxString *arg4 = 0 ;
33345 wxMenu *arg5 = (wxMenu *) 0 ;
33346 wxString const &arg6_defvalue = wxPyEmptyString ;
33347 wxString *arg6 = (wxString *) &arg6_defvalue ;
33348 wxMenuItem *result;
33349 bool temp4 = false ;
33350 bool temp6 = false ;
33351 PyObject * obj0 = 0 ;
33352 PyObject * obj1 = 0 ;
33353 PyObject * obj2 = 0 ;
33354 PyObject * obj3 = 0 ;
33355 PyObject * obj4 = 0 ;
33356 PyObject * obj5 = 0 ;
33357 char *kwnames[] = {
33358 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33359 };
33360
33361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33363 if (SWIG_arg_fail(1)) SWIG_fail;
33364 {
33365 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33366 if (SWIG_arg_fail(2)) SWIG_fail;
33367 }
33368 {
33369 arg3 = (int)(SWIG_As_int(obj2));
33370 if (SWIG_arg_fail(3)) SWIG_fail;
33371 }
33372 {
33373 arg4 = wxString_in_helper(obj3);
33374 if (arg4 == NULL) SWIG_fail;
33375 temp4 = true;
33376 }
33377 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33378 if (SWIG_arg_fail(5)) SWIG_fail;
33379 if (obj5) {
33380 {
33381 arg6 = wxString_in_helper(obj5);
33382 if (arg6 == NULL) SWIG_fail;
33383 temp6 = true;
33384 }
33385 }
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33389
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 {
33394 resultobj = wxPyMake_wxObject(result, 0);
33395 }
33396 {
33397 if (temp4)
33398 delete arg4;
33399 }
33400 {
33401 if (temp6)
33402 delete arg6;
33403 }
33404 return resultobj;
33405 fail:
33406 {
33407 if (temp4)
33408 delete arg4;
33409 }
33410 {
33411 if (temp6)
33412 delete arg6;
33413 }
33414 return NULL;
33415 }
33416
33417
33418 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33419 PyObject *resultobj;
33420 wxMenu *arg1 = (wxMenu *) 0 ;
33421 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33422 wxMenuItem *result;
33423 PyObject * obj0 = 0 ;
33424 PyObject * obj1 = 0 ;
33425 char *kwnames[] = {
33426 (char *) "self",(char *) "item", NULL
33427 };
33428
33429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33431 if (SWIG_arg_fail(1)) SWIG_fail;
33432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33433 if (SWIG_arg_fail(2)) SWIG_fail;
33434 {
33435 PyThreadState* __tstate = wxPyBeginAllowThreads();
33436 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33437
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 {
33442 resultobj = wxPyMake_wxObject(result, 0);
33443 }
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj;
33452 wxMenu *arg1 = (wxMenu *) 0 ;
33453 int arg2 ;
33454 wxString *arg3 = 0 ;
33455 wxString const &arg4_defvalue = wxPyEmptyString ;
33456 wxString *arg4 = (wxString *) &arg4_defvalue ;
33457 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33458 wxMenuItem *result;
33459 bool temp3 = false ;
33460 bool temp4 = false ;
33461 PyObject * obj0 = 0 ;
33462 PyObject * obj1 = 0 ;
33463 PyObject * obj2 = 0 ;
33464 PyObject * obj3 = 0 ;
33465 PyObject * obj4 = 0 ;
33466 char *kwnames[] = {
33467 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33468 };
33469
33470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33472 if (SWIG_arg_fail(1)) SWIG_fail;
33473 {
33474 arg2 = (int)(SWIG_As_int(obj1));
33475 if (SWIG_arg_fail(2)) SWIG_fail;
33476 }
33477 {
33478 arg3 = wxString_in_helper(obj2);
33479 if (arg3 == NULL) SWIG_fail;
33480 temp3 = true;
33481 }
33482 if (obj3) {
33483 {
33484 arg4 = wxString_in_helper(obj3);
33485 if (arg4 == NULL) SWIG_fail;
33486 temp4 = true;
33487 }
33488 }
33489 if (obj4) {
33490 {
33491 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33492 if (SWIG_arg_fail(5)) SWIG_fail;
33493 }
33494 }
33495 {
33496 PyThreadState* __tstate = wxPyBeginAllowThreads();
33497 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33498
33499 wxPyEndAllowThreads(__tstate);
33500 if (PyErr_Occurred()) SWIG_fail;
33501 }
33502 {
33503 resultobj = wxPyMake_wxObject(result, 0);
33504 }
33505 {
33506 if (temp3)
33507 delete arg3;
33508 }
33509 {
33510 if (temp4)
33511 delete arg4;
33512 }
33513 return resultobj;
33514 fail:
33515 {
33516 if (temp3)
33517 delete arg3;
33518 }
33519 {
33520 if (temp4)
33521 delete arg4;
33522 }
33523 return NULL;
33524 }
33525
33526
33527 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj;
33529 wxMenu *arg1 = (wxMenu *) 0 ;
33530 wxMenuItem *result;
33531 PyObject * obj0 = 0 ;
33532 char *kwnames[] = {
33533 (char *) "self", NULL
33534 };
33535
33536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33538 if (SWIG_arg_fail(1)) SWIG_fail;
33539 {
33540 PyThreadState* __tstate = wxPyBeginAllowThreads();
33541 result = (wxMenuItem *)(arg1)->PrependSeparator();
33542
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 {
33547 resultobj = wxPyMake_wxObject(result, 0);
33548 }
33549 return resultobj;
33550 fail:
33551 return NULL;
33552 }
33553
33554
33555 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33556 PyObject *resultobj;
33557 wxMenu *arg1 = (wxMenu *) 0 ;
33558 int arg2 ;
33559 wxString *arg3 = 0 ;
33560 wxString const &arg4_defvalue = wxPyEmptyString ;
33561 wxString *arg4 = (wxString *) &arg4_defvalue ;
33562 wxMenuItem *result;
33563 bool temp3 = false ;
33564 bool temp4 = false ;
33565 PyObject * obj0 = 0 ;
33566 PyObject * obj1 = 0 ;
33567 PyObject * obj2 = 0 ;
33568 PyObject * obj3 = 0 ;
33569 char *kwnames[] = {
33570 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33571 };
33572
33573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33575 if (SWIG_arg_fail(1)) SWIG_fail;
33576 {
33577 arg2 = (int)(SWIG_As_int(obj1));
33578 if (SWIG_arg_fail(2)) SWIG_fail;
33579 }
33580 {
33581 arg3 = wxString_in_helper(obj2);
33582 if (arg3 == NULL) SWIG_fail;
33583 temp3 = true;
33584 }
33585 if (obj3) {
33586 {
33587 arg4 = wxString_in_helper(obj3);
33588 if (arg4 == NULL) SWIG_fail;
33589 temp4 = true;
33590 }
33591 }
33592 {
33593 PyThreadState* __tstate = wxPyBeginAllowThreads();
33594 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33595
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 {
33600 resultobj = wxPyMake_wxObject(result, 0);
33601 }
33602 {
33603 if (temp3)
33604 delete arg3;
33605 }
33606 {
33607 if (temp4)
33608 delete arg4;
33609 }
33610 return resultobj;
33611 fail:
33612 {
33613 if (temp3)
33614 delete arg3;
33615 }
33616 {
33617 if (temp4)
33618 delete arg4;
33619 }
33620 return NULL;
33621 }
33622
33623
33624 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33625 PyObject *resultobj;
33626 wxMenu *arg1 = (wxMenu *) 0 ;
33627 int arg2 ;
33628 wxString *arg3 = 0 ;
33629 wxString const &arg4_defvalue = wxPyEmptyString ;
33630 wxString *arg4 = (wxString *) &arg4_defvalue ;
33631 wxMenuItem *result;
33632 bool temp3 = false ;
33633 bool temp4 = false ;
33634 PyObject * obj0 = 0 ;
33635 PyObject * obj1 = 0 ;
33636 PyObject * obj2 = 0 ;
33637 PyObject * obj3 = 0 ;
33638 char *kwnames[] = {
33639 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33640 };
33641
33642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33644 if (SWIG_arg_fail(1)) SWIG_fail;
33645 {
33646 arg2 = (int)(SWIG_As_int(obj1));
33647 if (SWIG_arg_fail(2)) SWIG_fail;
33648 }
33649 {
33650 arg3 = wxString_in_helper(obj2);
33651 if (arg3 == NULL) SWIG_fail;
33652 temp3 = true;
33653 }
33654 if (obj3) {
33655 {
33656 arg4 = wxString_in_helper(obj3);
33657 if (arg4 == NULL) SWIG_fail;
33658 temp4 = true;
33659 }
33660 }
33661 {
33662 PyThreadState* __tstate = wxPyBeginAllowThreads();
33663 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33664
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 {
33669 resultobj = wxPyMake_wxObject(result, 0);
33670 }
33671 {
33672 if (temp3)
33673 delete arg3;
33674 }
33675 {
33676 if (temp4)
33677 delete arg4;
33678 }
33679 return resultobj;
33680 fail:
33681 {
33682 if (temp3)
33683 delete arg3;
33684 }
33685 {
33686 if (temp4)
33687 delete arg4;
33688 }
33689 return NULL;
33690 }
33691
33692
33693 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33694 PyObject *resultobj;
33695 wxMenu *arg1 = (wxMenu *) 0 ;
33696 int arg2 ;
33697 wxString *arg3 = 0 ;
33698 wxMenu *arg4 = (wxMenu *) 0 ;
33699 wxString const &arg5_defvalue = wxPyEmptyString ;
33700 wxString *arg5 = (wxString *) &arg5_defvalue ;
33701 wxMenuItem *result;
33702 bool temp3 = false ;
33703 bool temp5 = false ;
33704 PyObject * obj0 = 0 ;
33705 PyObject * obj1 = 0 ;
33706 PyObject * obj2 = 0 ;
33707 PyObject * obj3 = 0 ;
33708 PyObject * obj4 = 0 ;
33709 char *kwnames[] = {
33710 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33711 };
33712
33713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33715 if (SWIG_arg_fail(1)) SWIG_fail;
33716 {
33717 arg2 = (int)(SWIG_As_int(obj1));
33718 if (SWIG_arg_fail(2)) SWIG_fail;
33719 }
33720 {
33721 arg3 = wxString_in_helper(obj2);
33722 if (arg3 == NULL) SWIG_fail;
33723 temp3 = true;
33724 }
33725 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33726 if (SWIG_arg_fail(4)) SWIG_fail;
33727 if (obj4) {
33728 {
33729 arg5 = wxString_in_helper(obj4);
33730 if (arg5 == NULL) SWIG_fail;
33731 temp5 = true;
33732 }
33733 }
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33737
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 {
33742 resultobj = wxPyMake_wxObject(result, 0);
33743 }
33744 {
33745 if (temp3)
33746 delete arg3;
33747 }
33748 {
33749 if (temp5)
33750 delete arg5;
33751 }
33752 return resultobj;
33753 fail:
33754 {
33755 if (temp3)
33756 delete arg3;
33757 }
33758 {
33759 if (temp5)
33760 delete arg5;
33761 }
33762 return NULL;
33763 }
33764
33765
33766 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33767 PyObject *resultobj;
33768 wxMenu *arg1 = (wxMenu *) 0 ;
33769 int arg2 ;
33770 wxMenuItem *result;
33771 PyObject * obj0 = 0 ;
33772 PyObject * obj1 = 0 ;
33773 char *kwnames[] = {
33774 (char *) "self",(char *) "id", NULL
33775 };
33776
33777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33779 if (SWIG_arg_fail(1)) SWIG_fail;
33780 {
33781 arg2 = (int)(SWIG_As_int(obj1));
33782 if (SWIG_arg_fail(2)) SWIG_fail;
33783 }
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 result = (wxMenuItem *)(arg1)->Remove(arg2);
33787
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 {
33792 resultobj = wxPyMake_wxObject(result, 0);
33793 }
33794 return resultobj;
33795 fail:
33796 return NULL;
33797 }
33798
33799
33800 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33801 PyObject *resultobj;
33802 wxMenu *arg1 = (wxMenu *) 0 ;
33803 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33804 wxMenuItem *result;
33805 PyObject * obj0 = 0 ;
33806 PyObject * obj1 = 0 ;
33807 char *kwnames[] = {
33808 (char *) "self",(char *) "item", NULL
33809 };
33810
33811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33813 if (SWIG_arg_fail(1)) SWIG_fail;
33814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33815 if (SWIG_arg_fail(2)) SWIG_fail;
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 result = (wxMenuItem *)(arg1)->Remove(arg2);
33819
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 {
33824 resultobj = wxPyMake_wxObject(result, 0);
33825 }
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj;
33834 wxMenu *arg1 = (wxMenu *) 0 ;
33835 int arg2 ;
33836 bool result;
33837 PyObject * obj0 = 0 ;
33838 PyObject * obj1 = 0 ;
33839 char *kwnames[] = {
33840 (char *) "self",(char *) "id", NULL
33841 };
33842
33843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33845 if (SWIG_arg_fail(1)) SWIG_fail;
33846 {
33847 arg2 = (int)(SWIG_As_int(obj1));
33848 if (SWIG_arg_fail(2)) SWIG_fail;
33849 }
33850 {
33851 PyThreadState* __tstate = wxPyBeginAllowThreads();
33852 result = (bool)(arg1)->Delete(arg2);
33853
33854 wxPyEndAllowThreads(__tstate);
33855 if (PyErr_Occurred()) SWIG_fail;
33856 }
33857 {
33858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33859 }
33860 return resultobj;
33861 fail:
33862 return NULL;
33863 }
33864
33865
33866 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33867 PyObject *resultobj;
33868 wxMenu *arg1 = (wxMenu *) 0 ;
33869 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33870 bool result;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 char *kwnames[] = {
33874 (char *) "self",(char *) "item", NULL
33875 };
33876
33877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33879 if (SWIG_arg_fail(1)) SWIG_fail;
33880 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(2)) SWIG_fail;
33882 {
33883 PyThreadState* __tstate = wxPyBeginAllowThreads();
33884 result = (bool)(arg1)->Delete(arg2);
33885
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 {
33890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33891 }
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj;
33900 wxMenu *arg1 = (wxMenu *) 0 ;
33901 PyObject * obj0 = 0 ;
33902 char *kwnames[] = {
33903 (char *) "self", NULL
33904 };
33905
33906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33908 if (SWIG_arg_fail(1)) SWIG_fail;
33909 {
33910 PyThreadState* __tstate = wxPyBeginAllowThreads();
33911 wxMenu_Destroy(arg1);
33912
33913 wxPyEndAllowThreads(__tstate);
33914 if (PyErr_Occurred()) SWIG_fail;
33915 }
33916 Py_INCREF(Py_None); resultobj = Py_None;
33917 return resultobj;
33918 fail:
33919 return NULL;
33920 }
33921
33922
33923 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33924 PyObject *resultobj;
33925 wxMenu *arg1 = (wxMenu *) 0 ;
33926 int arg2 ;
33927 bool result;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 char *kwnames[] = {
33931 (char *) "self",(char *) "id", NULL
33932 };
33933
33934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33936 if (SWIG_arg_fail(1)) SWIG_fail;
33937 {
33938 arg2 = (int)(SWIG_As_int(obj1));
33939 if (SWIG_arg_fail(2)) SWIG_fail;
33940 }
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 result = (bool)(arg1)->Destroy(arg2);
33944
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 {
33949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33950 }
33951 return resultobj;
33952 fail:
33953 return NULL;
33954 }
33955
33956
33957 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33958 PyObject *resultobj;
33959 wxMenu *arg1 = (wxMenu *) 0 ;
33960 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33961 bool result;
33962 PyObject * obj0 = 0 ;
33963 PyObject * obj1 = 0 ;
33964 char *kwnames[] = {
33965 (char *) "self",(char *) "item", NULL
33966 };
33967
33968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33970 if (SWIG_arg_fail(1)) SWIG_fail;
33971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33972 if (SWIG_arg_fail(2)) SWIG_fail;
33973 {
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (bool)(arg1)->Destroy(arg2);
33976
33977 wxPyEndAllowThreads(__tstate);
33978 if (PyErr_Occurred()) SWIG_fail;
33979 }
33980 {
33981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33982 }
33983 return resultobj;
33984 fail:
33985 return NULL;
33986 }
33987
33988
33989 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33990 PyObject *resultobj;
33991 wxMenu *arg1 = (wxMenu *) 0 ;
33992 size_t result;
33993 PyObject * obj0 = 0 ;
33994 char *kwnames[] = {
33995 (char *) "self", NULL
33996 };
33997
33998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34000 if (SWIG_arg_fail(1)) SWIG_fail;
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34004
34005 wxPyEndAllowThreads(__tstate);
34006 if (PyErr_Occurred()) SWIG_fail;
34007 }
34008 {
34009 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34010 }
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34018 PyObject *resultobj;
34019 wxMenu *arg1 = (wxMenu *) 0 ;
34020 PyObject *result;
34021 PyObject * obj0 = 0 ;
34022 char *kwnames[] = {
34023 (char *) "self", NULL
34024 };
34025
34026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34028 if (SWIG_arg_fail(1)) SWIG_fail;
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34032
34033 wxPyEndAllowThreads(__tstate);
34034 if (PyErr_Occurred()) SWIG_fail;
34035 }
34036 resultobj = result;
34037 return resultobj;
34038 fail:
34039 return NULL;
34040 }
34041
34042
34043 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34044 PyObject *resultobj;
34045 wxMenu *arg1 = (wxMenu *) 0 ;
34046 wxString *arg2 = 0 ;
34047 int result;
34048 bool temp2 = false ;
34049 PyObject * obj0 = 0 ;
34050 PyObject * obj1 = 0 ;
34051 char *kwnames[] = {
34052 (char *) "self",(char *) "item", NULL
34053 };
34054
34055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34057 if (SWIG_arg_fail(1)) SWIG_fail;
34058 {
34059 arg2 = wxString_in_helper(obj1);
34060 if (arg2 == NULL) SWIG_fail;
34061 temp2 = true;
34062 }
34063 {
34064 PyThreadState* __tstate = wxPyBeginAllowThreads();
34065 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34066
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 {
34071 resultobj = SWIG_From_int((int)(result));
34072 }
34073 {
34074 if (temp2)
34075 delete arg2;
34076 }
34077 return resultobj;
34078 fail:
34079 {
34080 if (temp2)
34081 delete arg2;
34082 }
34083 return NULL;
34084 }
34085
34086
34087 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34088 PyObject *resultobj;
34089 wxMenu *arg1 = (wxMenu *) 0 ;
34090 int arg2 ;
34091 wxMenuItem *result;
34092 PyObject * obj0 = 0 ;
34093 PyObject * obj1 = 0 ;
34094 char *kwnames[] = {
34095 (char *) "self",(char *) "id", NULL
34096 };
34097
34098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34100 if (SWIG_arg_fail(1)) SWIG_fail;
34101 {
34102 arg2 = (int)(SWIG_As_int(obj1));
34103 if (SWIG_arg_fail(2)) SWIG_fail;
34104 }
34105 {
34106 PyThreadState* __tstate = wxPyBeginAllowThreads();
34107 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34108
34109 wxPyEndAllowThreads(__tstate);
34110 if (PyErr_Occurred()) SWIG_fail;
34111 }
34112 {
34113 resultobj = wxPyMake_wxObject(result, 0);
34114 }
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj;
34123 wxMenu *arg1 = (wxMenu *) 0 ;
34124 size_t arg2 ;
34125 wxMenuItem *result;
34126 PyObject * obj0 = 0 ;
34127 PyObject * obj1 = 0 ;
34128 char *kwnames[] = {
34129 (char *) "self",(char *) "position", NULL
34130 };
34131
34132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34134 if (SWIG_arg_fail(1)) SWIG_fail;
34135 {
34136 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34137 if (SWIG_arg_fail(2)) SWIG_fail;
34138 }
34139 {
34140 PyThreadState* __tstate = wxPyBeginAllowThreads();
34141 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34142
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 {
34147 resultobj = wxPyMake_wxObject(result, 0);
34148 }
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj;
34157 wxMenu *arg1 = (wxMenu *) 0 ;
34158 int arg2 ;
34159 bool arg3 ;
34160 PyObject * obj0 = 0 ;
34161 PyObject * obj1 = 0 ;
34162 PyObject * obj2 = 0 ;
34163 char *kwnames[] = {
34164 (char *) "self",(char *) "id",(char *) "enable", NULL
34165 };
34166
34167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34169 if (SWIG_arg_fail(1)) SWIG_fail;
34170 {
34171 arg2 = (int)(SWIG_As_int(obj1));
34172 if (SWIG_arg_fail(2)) SWIG_fail;
34173 }
34174 {
34175 arg3 = (bool)(SWIG_As_bool(obj2));
34176 if (SWIG_arg_fail(3)) SWIG_fail;
34177 }
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 (arg1)->Enable(arg2,arg3);
34181
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 Py_INCREF(Py_None); resultobj = Py_None;
34186 return resultobj;
34187 fail:
34188 return NULL;
34189 }
34190
34191
34192 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34193 PyObject *resultobj;
34194 wxMenu *arg1 = (wxMenu *) 0 ;
34195 int arg2 ;
34196 bool result;
34197 PyObject * obj0 = 0 ;
34198 PyObject * obj1 = 0 ;
34199 char *kwnames[] = {
34200 (char *) "self",(char *) "id", NULL
34201 };
34202
34203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34205 if (SWIG_arg_fail(1)) SWIG_fail;
34206 {
34207 arg2 = (int)(SWIG_As_int(obj1));
34208 if (SWIG_arg_fail(2)) SWIG_fail;
34209 }
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34213
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 {
34218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34219 }
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34227 PyObject *resultobj;
34228 wxMenu *arg1 = (wxMenu *) 0 ;
34229 int arg2 ;
34230 bool arg3 ;
34231 PyObject * obj0 = 0 ;
34232 PyObject * obj1 = 0 ;
34233 PyObject * obj2 = 0 ;
34234 char *kwnames[] = {
34235 (char *) "self",(char *) "id",(char *) "check", NULL
34236 };
34237
34238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34240 if (SWIG_arg_fail(1)) SWIG_fail;
34241 {
34242 arg2 = (int)(SWIG_As_int(obj1));
34243 if (SWIG_arg_fail(2)) SWIG_fail;
34244 }
34245 {
34246 arg3 = (bool)(SWIG_As_bool(obj2));
34247 if (SWIG_arg_fail(3)) SWIG_fail;
34248 }
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 (arg1)->Check(arg2,arg3);
34252
34253 wxPyEndAllowThreads(__tstate);
34254 if (PyErr_Occurred()) SWIG_fail;
34255 }
34256 Py_INCREF(Py_None); resultobj = Py_None;
34257 return resultobj;
34258 fail:
34259 return NULL;
34260 }
34261
34262
34263 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34264 PyObject *resultobj;
34265 wxMenu *arg1 = (wxMenu *) 0 ;
34266 int arg2 ;
34267 bool result;
34268 PyObject * obj0 = 0 ;
34269 PyObject * obj1 = 0 ;
34270 char *kwnames[] = {
34271 (char *) "self",(char *) "id", NULL
34272 };
34273
34274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34276 if (SWIG_arg_fail(1)) SWIG_fail;
34277 {
34278 arg2 = (int)(SWIG_As_int(obj1));
34279 if (SWIG_arg_fail(2)) SWIG_fail;
34280 }
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34284
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 {
34289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34290 }
34291 return resultobj;
34292 fail:
34293 return NULL;
34294 }
34295
34296
34297 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34298 PyObject *resultobj;
34299 wxMenu *arg1 = (wxMenu *) 0 ;
34300 int arg2 ;
34301 wxString *arg3 = 0 ;
34302 bool temp3 = false ;
34303 PyObject * obj0 = 0 ;
34304 PyObject * obj1 = 0 ;
34305 PyObject * obj2 = 0 ;
34306 char *kwnames[] = {
34307 (char *) "self",(char *) "id",(char *) "label", NULL
34308 };
34309
34310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34312 if (SWIG_arg_fail(1)) SWIG_fail;
34313 {
34314 arg2 = (int)(SWIG_As_int(obj1));
34315 if (SWIG_arg_fail(2)) SWIG_fail;
34316 }
34317 {
34318 arg3 = wxString_in_helper(obj2);
34319 if (arg3 == NULL) SWIG_fail;
34320 temp3 = true;
34321 }
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34325
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 Py_INCREF(Py_None); resultobj = Py_None;
34330 {
34331 if (temp3)
34332 delete arg3;
34333 }
34334 return resultobj;
34335 fail:
34336 {
34337 if (temp3)
34338 delete arg3;
34339 }
34340 return NULL;
34341 }
34342
34343
34344 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34345 PyObject *resultobj;
34346 wxMenu *arg1 = (wxMenu *) 0 ;
34347 int arg2 ;
34348 wxString result;
34349 PyObject * obj0 = 0 ;
34350 PyObject * obj1 = 0 ;
34351 char *kwnames[] = {
34352 (char *) "self",(char *) "id", NULL
34353 };
34354
34355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34357 if (SWIG_arg_fail(1)) SWIG_fail;
34358 {
34359 arg2 = (int)(SWIG_As_int(obj1));
34360 if (SWIG_arg_fail(2)) SWIG_fail;
34361 }
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34365
34366 wxPyEndAllowThreads(__tstate);
34367 if (PyErr_Occurred()) SWIG_fail;
34368 }
34369 {
34370 #if wxUSE_UNICODE
34371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34372 #else
34373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34374 #endif
34375 }
34376 return resultobj;
34377 fail:
34378 return NULL;
34379 }
34380
34381
34382 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34383 PyObject *resultobj;
34384 wxMenu *arg1 = (wxMenu *) 0 ;
34385 int arg2 ;
34386 wxString *arg3 = 0 ;
34387 bool temp3 = false ;
34388 PyObject * obj0 = 0 ;
34389 PyObject * obj1 = 0 ;
34390 PyObject * obj2 = 0 ;
34391 char *kwnames[] = {
34392 (char *) "self",(char *) "id",(char *) "helpString", NULL
34393 };
34394
34395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34397 if (SWIG_arg_fail(1)) SWIG_fail;
34398 {
34399 arg2 = (int)(SWIG_As_int(obj1));
34400 if (SWIG_arg_fail(2)) SWIG_fail;
34401 }
34402 {
34403 arg3 = wxString_in_helper(obj2);
34404 if (arg3 == NULL) SWIG_fail;
34405 temp3 = true;
34406 }
34407 {
34408 PyThreadState* __tstate = wxPyBeginAllowThreads();
34409 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34410
34411 wxPyEndAllowThreads(__tstate);
34412 if (PyErr_Occurred()) SWIG_fail;
34413 }
34414 Py_INCREF(Py_None); resultobj = Py_None;
34415 {
34416 if (temp3)
34417 delete arg3;
34418 }
34419 return resultobj;
34420 fail:
34421 {
34422 if (temp3)
34423 delete arg3;
34424 }
34425 return NULL;
34426 }
34427
34428
34429 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34430 PyObject *resultobj;
34431 wxMenu *arg1 = (wxMenu *) 0 ;
34432 int arg2 ;
34433 wxString result;
34434 PyObject * obj0 = 0 ;
34435 PyObject * obj1 = 0 ;
34436 char *kwnames[] = {
34437 (char *) "self",(char *) "id", NULL
34438 };
34439
34440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34442 if (SWIG_arg_fail(1)) SWIG_fail;
34443 {
34444 arg2 = (int)(SWIG_As_int(obj1));
34445 if (SWIG_arg_fail(2)) SWIG_fail;
34446 }
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34450
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 {
34455 #if wxUSE_UNICODE
34456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34457 #else
34458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34459 #endif
34460 }
34461 return resultobj;
34462 fail:
34463 return NULL;
34464 }
34465
34466
34467 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34468 PyObject *resultobj;
34469 wxMenu *arg1 = (wxMenu *) 0 ;
34470 wxString *arg2 = 0 ;
34471 bool temp2 = false ;
34472 PyObject * obj0 = 0 ;
34473 PyObject * obj1 = 0 ;
34474 char *kwnames[] = {
34475 (char *) "self",(char *) "title", NULL
34476 };
34477
34478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34480 if (SWIG_arg_fail(1)) SWIG_fail;
34481 {
34482 arg2 = wxString_in_helper(obj1);
34483 if (arg2 == NULL) SWIG_fail;
34484 temp2 = true;
34485 }
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 (arg1)->SetTitle((wxString const &)*arg2);
34489
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 Py_INCREF(Py_None); resultobj = Py_None;
34494 {
34495 if (temp2)
34496 delete arg2;
34497 }
34498 return resultobj;
34499 fail:
34500 {
34501 if (temp2)
34502 delete arg2;
34503 }
34504 return NULL;
34505 }
34506
34507
34508 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34509 PyObject *resultobj;
34510 wxMenu *arg1 = (wxMenu *) 0 ;
34511 wxString result;
34512 PyObject * obj0 = 0 ;
34513 char *kwnames[] = {
34514 (char *) "self", NULL
34515 };
34516
34517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34519 if (SWIG_arg_fail(1)) SWIG_fail;
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 result = ((wxMenu const *)arg1)->GetTitle();
34523
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 {
34528 #if wxUSE_UNICODE
34529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34530 #else
34531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34532 #endif
34533 }
34534 return resultobj;
34535 fail:
34536 return NULL;
34537 }
34538
34539
34540 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34541 PyObject *resultobj;
34542 wxMenu *arg1 = (wxMenu *) 0 ;
34543 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34544 PyObject * obj0 = 0 ;
34545 PyObject * obj1 = 0 ;
34546 char *kwnames[] = {
34547 (char *) "self",(char *) "handler", NULL
34548 };
34549
34550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34552 if (SWIG_arg_fail(1)) SWIG_fail;
34553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34554 if (SWIG_arg_fail(2)) SWIG_fail;
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 (arg1)->SetEventHandler(arg2);
34558
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 Py_INCREF(Py_None); resultobj = Py_None;
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34570 PyObject *resultobj;
34571 wxMenu *arg1 = (wxMenu *) 0 ;
34572 wxEvtHandler *result;
34573 PyObject * obj0 = 0 ;
34574 char *kwnames[] = {
34575 (char *) "self", NULL
34576 };
34577
34578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34580 if (SWIG_arg_fail(1)) SWIG_fail;
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34584
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 {
34589 resultobj = wxPyMake_wxObject(result, 0);
34590 }
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj;
34599 wxMenu *arg1 = (wxMenu *) 0 ;
34600 wxWindow *arg2 = (wxWindow *) 0 ;
34601 PyObject * obj0 = 0 ;
34602 PyObject * obj1 = 0 ;
34603 char *kwnames[] = {
34604 (char *) "self",(char *) "win", NULL
34605 };
34606
34607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34609 if (SWIG_arg_fail(1)) SWIG_fail;
34610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34611 if (SWIG_arg_fail(2)) SWIG_fail;
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 (arg1)->SetInvokingWindow(arg2);
34615
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 Py_INCREF(Py_None); resultobj = Py_None;
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj;
34628 wxMenu *arg1 = (wxMenu *) 0 ;
34629 wxWindow *result;
34630 PyObject * obj0 = 0 ;
34631 char *kwnames[] = {
34632 (char *) "self", NULL
34633 };
34634
34635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34637 if (SWIG_arg_fail(1)) SWIG_fail;
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34641
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 {
34646 resultobj = wxPyMake_wxObject(result, 0);
34647 }
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34655 PyObject *resultobj;
34656 wxMenu *arg1 = (wxMenu *) 0 ;
34657 long result;
34658 PyObject * obj0 = 0 ;
34659 char *kwnames[] = {
34660 (char *) "self", NULL
34661 };
34662
34663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34665 if (SWIG_arg_fail(1)) SWIG_fail;
34666 {
34667 PyThreadState* __tstate = wxPyBeginAllowThreads();
34668 result = (long)((wxMenu const *)arg1)->GetStyle();
34669
34670 wxPyEndAllowThreads(__tstate);
34671 if (PyErr_Occurred()) SWIG_fail;
34672 }
34673 {
34674 resultobj = SWIG_From_long((long)(result));
34675 }
34676 return resultobj;
34677 fail:
34678 return NULL;
34679 }
34680
34681
34682 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34683 PyObject *resultobj;
34684 wxMenu *arg1 = (wxMenu *) 0 ;
34685 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34686 PyObject * obj0 = 0 ;
34687 PyObject * obj1 = 0 ;
34688 char *kwnames[] = {
34689 (char *) "self",(char *) "source", NULL
34690 };
34691
34692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34694 if (SWIG_arg_fail(1)) SWIG_fail;
34695 if (obj1) {
34696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34697 if (SWIG_arg_fail(2)) SWIG_fail;
34698 }
34699 {
34700 PyThreadState* __tstate = wxPyBeginAllowThreads();
34701 (arg1)->UpdateUI(arg2);
34702
34703 wxPyEndAllowThreads(__tstate);
34704 if (PyErr_Occurred()) SWIG_fail;
34705 }
34706 Py_INCREF(Py_None); resultobj = Py_None;
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34714 PyObject *resultobj;
34715 wxMenu *arg1 = (wxMenu *) 0 ;
34716 wxMenuBar *result;
34717 PyObject * obj0 = 0 ;
34718 char *kwnames[] = {
34719 (char *) "self", NULL
34720 };
34721
34722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34724 if (SWIG_arg_fail(1)) SWIG_fail;
34725 {
34726 PyThreadState* __tstate = wxPyBeginAllowThreads();
34727 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34728
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 {
34733 resultobj = wxPyMake_wxObject(result, 0);
34734 }
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34742 PyObject *resultobj;
34743 wxMenu *arg1 = (wxMenu *) 0 ;
34744 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34745 PyObject * obj0 = 0 ;
34746 PyObject * obj1 = 0 ;
34747 char *kwnames[] = {
34748 (char *) "self",(char *) "menubar", NULL
34749 };
34750
34751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34753 if (SWIG_arg_fail(1)) SWIG_fail;
34754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34755 if (SWIG_arg_fail(2)) SWIG_fail;
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 (arg1)->Attach(arg2);
34759
34760 wxPyEndAllowThreads(__tstate);
34761 if (PyErr_Occurred()) SWIG_fail;
34762 }
34763 Py_INCREF(Py_None); resultobj = Py_None;
34764 return resultobj;
34765 fail:
34766 return NULL;
34767 }
34768
34769
34770 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34771 PyObject *resultobj;
34772 wxMenu *arg1 = (wxMenu *) 0 ;
34773 PyObject * obj0 = 0 ;
34774 char *kwnames[] = {
34775 (char *) "self", NULL
34776 };
34777
34778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34780 if (SWIG_arg_fail(1)) SWIG_fail;
34781 {
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 (arg1)->Detach();
34784
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 Py_INCREF(Py_None); resultobj = Py_None;
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj;
34797 wxMenu *arg1 = (wxMenu *) 0 ;
34798 bool result;
34799 PyObject * obj0 = 0 ;
34800 char *kwnames[] = {
34801 (char *) "self", NULL
34802 };
34803
34804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34806 if (SWIG_arg_fail(1)) SWIG_fail;
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 result = (bool)((wxMenu const *)arg1)->IsAttached();
34810
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 {
34815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34816 }
34817 return resultobj;
34818 fail:
34819 return NULL;
34820 }
34821
34822
34823 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34824 PyObject *resultobj;
34825 wxMenu *arg1 = (wxMenu *) 0 ;
34826 wxMenu *arg2 = (wxMenu *) 0 ;
34827 PyObject * obj0 = 0 ;
34828 PyObject * obj1 = 0 ;
34829 char *kwnames[] = {
34830 (char *) "self",(char *) "parent", NULL
34831 };
34832
34833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34835 if (SWIG_arg_fail(1)) SWIG_fail;
34836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34837 if (SWIG_arg_fail(2)) SWIG_fail;
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 (arg1)->SetParent(arg2);
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 Py_INCREF(Py_None); resultobj = Py_None;
34846 return resultobj;
34847 fail:
34848 return NULL;
34849 }
34850
34851
34852 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34853 PyObject *resultobj;
34854 wxMenu *arg1 = (wxMenu *) 0 ;
34855 wxMenu *result;
34856 PyObject * obj0 = 0 ;
34857 char *kwnames[] = {
34858 (char *) "self", NULL
34859 };
34860
34861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34863 if (SWIG_arg_fail(1)) SWIG_fail;
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34867
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = wxPyMake_wxObject(result, 0);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34881 PyObject *obj;
34882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34883 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34884 Py_INCREF(obj);
34885 return Py_BuildValue((char *)"");
34886 }
34887 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj;
34889 long arg1 = (long) 0 ;
34890 wxMenuBar *result;
34891 PyObject * obj0 = 0 ;
34892 char *kwnames[] = {
34893 (char *) "style", NULL
34894 };
34895
34896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34897 if (obj0) {
34898 {
34899 arg1 = (long)(SWIG_As_long(obj0));
34900 if (SWIG_arg_fail(1)) SWIG_fail;
34901 }
34902 }
34903 {
34904 if (!wxPyCheckForApp()) SWIG_fail;
34905 PyThreadState* __tstate = wxPyBeginAllowThreads();
34906 result = (wxMenuBar *)new wxMenuBar(arg1);
34907
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34912 return resultobj;
34913 fail:
34914 return NULL;
34915 }
34916
34917
34918 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34919 PyObject *resultobj;
34920 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34921 wxMenu *arg2 = (wxMenu *) 0 ;
34922 wxString *arg3 = 0 ;
34923 bool result;
34924 bool temp3 = false ;
34925 PyObject * obj0 = 0 ;
34926 PyObject * obj1 = 0 ;
34927 PyObject * obj2 = 0 ;
34928 char *kwnames[] = {
34929 (char *) "self",(char *) "menu",(char *) "title", NULL
34930 };
34931
34932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34934 if (SWIG_arg_fail(1)) SWIG_fail;
34935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34936 if (SWIG_arg_fail(2)) SWIG_fail;
34937 {
34938 arg3 = wxString_in_helper(obj2);
34939 if (arg3 == NULL) SWIG_fail;
34940 temp3 = true;
34941 }
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34945
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 {
34950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34951 }
34952 {
34953 if (temp3)
34954 delete arg3;
34955 }
34956 return resultobj;
34957 fail:
34958 {
34959 if (temp3)
34960 delete arg3;
34961 }
34962 return NULL;
34963 }
34964
34965
34966 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34967 PyObject *resultobj;
34968 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34969 size_t arg2 ;
34970 wxMenu *arg3 = (wxMenu *) 0 ;
34971 wxString *arg4 = 0 ;
34972 bool result;
34973 bool temp4 = false ;
34974 PyObject * obj0 = 0 ;
34975 PyObject * obj1 = 0 ;
34976 PyObject * obj2 = 0 ;
34977 PyObject * obj3 = 0 ;
34978 char *kwnames[] = {
34979 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34980 };
34981
34982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34984 if (SWIG_arg_fail(1)) SWIG_fail;
34985 {
34986 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34987 if (SWIG_arg_fail(2)) SWIG_fail;
34988 }
34989 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34990 if (SWIG_arg_fail(3)) SWIG_fail;
34991 {
34992 arg4 = wxString_in_helper(obj3);
34993 if (arg4 == NULL) SWIG_fail;
34994 temp4 = true;
34995 }
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34999
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 {
35004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35005 }
35006 {
35007 if (temp4)
35008 delete arg4;
35009 }
35010 return resultobj;
35011 fail:
35012 {
35013 if (temp4)
35014 delete arg4;
35015 }
35016 return NULL;
35017 }
35018
35019
35020 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35021 PyObject *resultobj;
35022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35023 size_t result;
35024 PyObject * obj0 = 0 ;
35025 char *kwnames[] = {
35026 (char *) "self", NULL
35027 };
35028
35029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35031 if (SWIG_arg_fail(1)) SWIG_fail;
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35035
35036 wxPyEndAllowThreads(__tstate);
35037 if (PyErr_Occurred()) SWIG_fail;
35038 }
35039 {
35040 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35041 }
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj;
35050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35051 size_t arg2 ;
35052 wxMenu *result;
35053 PyObject * obj0 = 0 ;
35054 PyObject * obj1 = 0 ;
35055 char *kwnames[] = {
35056 (char *) "self",(char *) "pos", NULL
35057 };
35058
35059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35061 if (SWIG_arg_fail(1)) SWIG_fail;
35062 {
35063 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35064 if (SWIG_arg_fail(2)) SWIG_fail;
35065 }
35066 {
35067 PyThreadState* __tstate = wxPyBeginAllowThreads();
35068 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35069
35070 wxPyEndAllowThreads(__tstate);
35071 if (PyErr_Occurred()) SWIG_fail;
35072 }
35073 {
35074 resultobj = wxPyMake_wxObject(result, 0);
35075 }
35076 return resultobj;
35077 fail:
35078 return NULL;
35079 }
35080
35081
35082 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35083 PyObject *resultobj;
35084 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35085 size_t arg2 ;
35086 wxMenu *arg3 = (wxMenu *) 0 ;
35087 wxString *arg4 = 0 ;
35088 wxMenu *result;
35089 bool temp4 = false ;
35090 PyObject * obj0 = 0 ;
35091 PyObject * obj1 = 0 ;
35092 PyObject * obj2 = 0 ;
35093 PyObject * obj3 = 0 ;
35094 char *kwnames[] = {
35095 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35096 };
35097
35098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35100 if (SWIG_arg_fail(1)) SWIG_fail;
35101 {
35102 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35103 if (SWIG_arg_fail(2)) SWIG_fail;
35104 }
35105 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35106 if (SWIG_arg_fail(3)) SWIG_fail;
35107 {
35108 arg4 = wxString_in_helper(obj3);
35109 if (arg4 == NULL) SWIG_fail;
35110 temp4 = true;
35111 }
35112 {
35113 PyThreadState* __tstate = wxPyBeginAllowThreads();
35114 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35115
35116 wxPyEndAllowThreads(__tstate);
35117 if (PyErr_Occurred()) SWIG_fail;
35118 }
35119 {
35120 resultobj = wxPyMake_wxObject(result, 0);
35121 }
35122 {
35123 if (temp4)
35124 delete arg4;
35125 }
35126 return resultobj;
35127 fail:
35128 {
35129 if (temp4)
35130 delete arg4;
35131 }
35132 return NULL;
35133 }
35134
35135
35136 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35137 PyObject *resultobj;
35138 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35139 size_t arg2 ;
35140 wxMenu *result;
35141 PyObject * obj0 = 0 ;
35142 PyObject * obj1 = 0 ;
35143 char *kwnames[] = {
35144 (char *) "self",(char *) "pos", NULL
35145 };
35146
35147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35149 if (SWIG_arg_fail(1)) SWIG_fail;
35150 {
35151 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35152 if (SWIG_arg_fail(2)) SWIG_fail;
35153 }
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 result = (wxMenu *)(arg1)->Remove(arg2);
35157
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 {
35162 resultobj = wxPyMake_wxObject(result, 0);
35163 }
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35171 PyObject *resultobj;
35172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35173 size_t arg2 ;
35174 bool arg3 ;
35175 PyObject * obj0 = 0 ;
35176 PyObject * obj1 = 0 ;
35177 PyObject * obj2 = 0 ;
35178 char *kwnames[] = {
35179 (char *) "self",(char *) "pos",(char *) "enable", NULL
35180 };
35181
35182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35184 if (SWIG_arg_fail(1)) SWIG_fail;
35185 {
35186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35187 if (SWIG_arg_fail(2)) SWIG_fail;
35188 }
35189 {
35190 arg3 = (bool)(SWIG_As_bool(obj2));
35191 if (SWIG_arg_fail(3)) SWIG_fail;
35192 }
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 (arg1)->EnableTop(arg2,arg3);
35196
35197 wxPyEndAllowThreads(__tstate);
35198 if (PyErr_Occurred()) SWIG_fail;
35199 }
35200 Py_INCREF(Py_None); resultobj = Py_None;
35201 return resultobj;
35202 fail:
35203 return NULL;
35204 }
35205
35206
35207 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35208 PyObject *resultobj;
35209 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35210 size_t arg2 ;
35211 bool result;
35212 PyObject * obj0 = 0 ;
35213 PyObject * obj1 = 0 ;
35214 char *kwnames[] = {
35215 (char *) "self",(char *) "pos", NULL
35216 };
35217
35218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35220 if (SWIG_arg_fail(1)) SWIG_fail;
35221 {
35222 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35223 if (SWIG_arg_fail(2)) SWIG_fail;
35224 }
35225 {
35226 PyThreadState* __tstate = wxPyBeginAllowThreads();
35227 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35228
35229 wxPyEndAllowThreads(__tstate);
35230 if (PyErr_Occurred()) SWIG_fail;
35231 }
35232 {
35233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35234 }
35235 return resultobj;
35236 fail:
35237 return NULL;
35238 }
35239
35240
35241 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35242 PyObject *resultobj;
35243 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35244 size_t arg2 ;
35245 wxString *arg3 = 0 ;
35246 bool temp3 = false ;
35247 PyObject * obj0 = 0 ;
35248 PyObject * obj1 = 0 ;
35249 PyObject * obj2 = 0 ;
35250 char *kwnames[] = {
35251 (char *) "self",(char *) "pos",(char *) "label", NULL
35252 };
35253
35254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35256 if (SWIG_arg_fail(1)) SWIG_fail;
35257 {
35258 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35259 if (SWIG_arg_fail(2)) SWIG_fail;
35260 }
35261 {
35262 arg3 = wxString_in_helper(obj2);
35263 if (arg3 == NULL) SWIG_fail;
35264 temp3 = true;
35265 }
35266 {
35267 PyThreadState* __tstate = wxPyBeginAllowThreads();
35268 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35269
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 Py_INCREF(Py_None); resultobj = Py_None;
35274 {
35275 if (temp3)
35276 delete arg3;
35277 }
35278 return resultobj;
35279 fail:
35280 {
35281 if (temp3)
35282 delete arg3;
35283 }
35284 return NULL;
35285 }
35286
35287
35288 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35289 PyObject *resultobj;
35290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35291 size_t arg2 ;
35292 wxString result;
35293 PyObject * obj0 = 0 ;
35294 PyObject * obj1 = 0 ;
35295 char *kwnames[] = {
35296 (char *) "self",(char *) "pos", NULL
35297 };
35298
35299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35301 if (SWIG_arg_fail(1)) SWIG_fail;
35302 {
35303 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35304 if (SWIG_arg_fail(2)) SWIG_fail;
35305 }
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35309
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 {
35314 #if wxUSE_UNICODE
35315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35316 #else
35317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35318 #endif
35319 }
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj;
35328 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35329 wxString *arg2 = 0 ;
35330 wxString *arg3 = 0 ;
35331 int result;
35332 bool temp2 = false ;
35333 bool temp3 = false ;
35334 PyObject * obj0 = 0 ;
35335 PyObject * obj1 = 0 ;
35336 PyObject * obj2 = 0 ;
35337 char *kwnames[] = {
35338 (char *) "self",(char *) "menu",(char *) "item", NULL
35339 };
35340
35341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35343 if (SWIG_arg_fail(1)) SWIG_fail;
35344 {
35345 arg2 = wxString_in_helper(obj1);
35346 if (arg2 == NULL) SWIG_fail;
35347 temp2 = true;
35348 }
35349 {
35350 arg3 = wxString_in_helper(obj2);
35351 if (arg3 == NULL) SWIG_fail;
35352 temp3 = true;
35353 }
35354 {
35355 PyThreadState* __tstate = wxPyBeginAllowThreads();
35356 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35357
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 {
35362 resultobj = SWIG_From_int((int)(result));
35363 }
35364 {
35365 if (temp2)
35366 delete arg2;
35367 }
35368 {
35369 if (temp3)
35370 delete arg3;
35371 }
35372 return resultobj;
35373 fail:
35374 {
35375 if (temp2)
35376 delete arg2;
35377 }
35378 {
35379 if (temp3)
35380 delete arg3;
35381 }
35382 return NULL;
35383 }
35384
35385
35386 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35387 PyObject *resultobj;
35388 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35389 int arg2 ;
35390 wxMenuItem *result;
35391 PyObject * obj0 = 0 ;
35392 PyObject * obj1 = 0 ;
35393 char *kwnames[] = {
35394 (char *) "self",(char *) "id", NULL
35395 };
35396
35397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35399 if (SWIG_arg_fail(1)) SWIG_fail;
35400 {
35401 arg2 = (int)(SWIG_As_int(obj1));
35402 if (SWIG_arg_fail(2)) SWIG_fail;
35403 }
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35407
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = wxPyMake_wxObject(result, 0);
35413 }
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35421 PyObject *resultobj;
35422 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35423 wxString *arg2 = 0 ;
35424 int result;
35425 bool temp2 = false ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 char *kwnames[] = {
35429 (char *) "self",(char *) "title", NULL
35430 };
35431
35432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35434 if (SWIG_arg_fail(1)) SWIG_fail;
35435 {
35436 arg2 = wxString_in_helper(obj1);
35437 if (arg2 == NULL) SWIG_fail;
35438 temp2 = true;
35439 }
35440 {
35441 PyThreadState* __tstate = wxPyBeginAllowThreads();
35442 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35443
35444 wxPyEndAllowThreads(__tstate);
35445 if (PyErr_Occurred()) SWIG_fail;
35446 }
35447 {
35448 resultobj = SWIG_From_int((int)(result));
35449 }
35450 {
35451 if (temp2)
35452 delete arg2;
35453 }
35454 return resultobj;
35455 fail:
35456 {
35457 if (temp2)
35458 delete arg2;
35459 }
35460 return NULL;
35461 }
35462
35463
35464 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35465 PyObject *resultobj;
35466 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35467 int arg2 ;
35468 bool arg3 ;
35469 PyObject * obj0 = 0 ;
35470 PyObject * obj1 = 0 ;
35471 PyObject * obj2 = 0 ;
35472 char *kwnames[] = {
35473 (char *) "self",(char *) "id",(char *) "enable", NULL
35474 };
35475
35476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35478 if (SWIG_arg_fail(1)) SWIG_fail;
35479 {
35480 arg2 = (int)(SWIG_As_int(obj1));
35481 if (SWIG_arg_fail(2)) SWIG_fail;
35482 }
35483 {
35484 arg3 = (bool)(SWIG_As_bool(obj2));
35485 if (SWIG_arg_fail(3)) SWIG_fail;
35486 }
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 (arg1)->Enable(arg2,arg3);
35490
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 Py_INCREF(Py_None); resultobj = Py_None;
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj;
35503 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35504 int arg2 ;
35505 bool arg3 ;
35506 PyObject * obj0 = 0 ;
35507 PyObject * obj1 = 0 ;
35508 PyObject * obj2 = 0 ;
35509 char *kwnames[] = {
35510 (char *) "self",(char *) "id",(char *) "check", NULL
35511 };
35512
35513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35515 if (SWIG_arg_fail(1)) SWIG_fail;
35516 {
35517 arg2 = (int)(SWIG_As_int(obj1));
35518 if (SWIG_arg_fail(2)) SWIG_fail;
35519 }
35520 {
35521 arg3 = (bool)(SWIG_As_bool(obj2));
35522 if (SWIG_arg_fail(3)) SWIG_fail;
35523 }
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 (arg1)->Check(arg2,arg3);
35527
35528 wxPyEndAllowThreads(__tstate);
35529 if (PyErr_Occurred()) SWIG_fail;
35530 }
35531 Py_INCREF(Py_None); resultobj = Py_None;
35532 return resultobj;
35533 fail:
35534 return NULL;
35535 }
35536
35537
35538 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35539 PyObject *resultobj;
35540 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35541 int arg2 ;
35542 bool result;
35543 PyObject * obj0 = 0 ;
35544 PyObject * obj1 = 0 ;
35545 char *kwnames[] = {
35546 (char *) "self",(char *) "id", NULL
35547 };
35548
35549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35551 if (SWIG_arg_fail(1)) SWIG_fail;
35552 {
35553 arg2 = (int)(SWIG_As_int(obj1));
35554 if (SWIG_arg_fail(2)) SWIG_fail;
35555 }
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35559
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 {
35564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj;
35574 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35575 int arg2 ;
35576 bool result;
35577 PyObject * obj0 = 0 ;
35578 PyObject * obj1 = 0 ;
35579 char *kwnames[] = {
35580 (char *) "self",(char *) "id", NULL
35581 };
35582
35583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35585 if (SWIG_arg_fail(1)) SWIG_fail;
35586 {
35587 arg2 = (int)(SWIG_As_int(obj1));
35588 if (SWIG_arg_fail(2)) SWIG_fail;
35589 }
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35593
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 {
35598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35599 }
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj;
35608 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35609 int arg2 ;
35610 wxString *arg3 = 0 ;
35611 bool temp3 = false ;
35612 PyObject * obj0 = 0 ;
35613 PyObject * obj1 = 0 ;
35614 PyObject * obj2 = 0 ;
35615 char *kwnames[] = {
35616 (char *) "self",(char *) "id",(char *) "label", NULL
35617 };
35618
35619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35621 if (SWIG_arg_fail(1)) SWIG_fail;
35622 {
35623 arg2 = (int)(SWIG_As_int(obj1));
35624 if (SWIG_arg_fail(2)) SWIG_fail;
35625 }
35626 {
35627 arg3 = wxString_in_helper(obj2);
35628 if (arg3 == NULL) SWIG_fail;
35629 temp3 = true;
35630 }
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35634
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 Py_INCREF(Py_None); resultobj = Py_None;
35639 {
35640 if (temp3)
35641 delete arg3;
35642 }
35643 return resultobj;
35644 fail:
35645 {
35646 if (temp3)
35647 delete arg3;
35648 }
35649 return NULL;
35650 }
35651
35652
35653 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35654 PyObject *resultobj;
35655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35656 int arg2 ;
35657 wxString result;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 char *kwnames[] = {
35661 (char *) "self",(char *) "id", NULL
35662 };
35663
35664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35666 if (SWIG_arg_fail(1)) SWIG_fail;
35667 {
35668 arg2 = (int)(SWIG_As_int(obj1));
35669 if (SWIG_arg_fail(2)) SWIG_fail;
35670 }
35671 {
35672 PyThreadState* __tstate = wxPyBeginAllowThreads();
35673 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35674
35675 wxPyEndAllowThreads(__tstate);
35676 if (PyErr_Occurred()) SWIG_fail;
35677 }
35678 {
35679 #if wxUSE_UNICODE
35680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35681 #else
35682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35683 #endif
35684 }
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35692 PyObject *resultobj;
35693 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35694 int arg2 ;
35695 wxString *arg3 = 0 ;
35696 bool temp3 = false ;
35697 PyObject * obj0 = 0 ;
35698 PyObject * obj1 = 0 ;
35699 PyObject * obj2 = 0 ;
35700 char *kwnames[] = {
35701 (char *) "self",(char *) "id",(char *) "helpString", NULL
35702 };
35703
35704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35706 if (SWIG_arg_fail(1)) SWIG_fail;
35707 {
35708 arg2 = (int)(SWIG_As_int(obj1));
35709 if (SWIG_arg_fail(2)) SWIG_fail;
35710 }
35711 {
35712 arg3 = wxString_in_helper(obj2);
35713 if (arg3 == NULL) SWIG_fail;
35714 temp3 = true;
35715 }
35716 {
35717 PyThreadState* __tstate = wxPyBeginAllowThreads();
35718 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35719
35720 wxPyEndAllowThreads(__tstate);
35721 if (PyErr_Occurred()) SWIG_fail;
35722 }
35723 Py_INCREF(Py_None); resultobj = Py_None;
35724 {
35725 if (temp3)
35726 delete arg3;
35727 }
35728 return resultobj;
35729 fail:
35730 {
35731 if (temp3)
35732 delete arg3;
35733 }
35734 return NULL;
35735 }
35736
35737
35738 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35739 PyObject *resultobj;
35740 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35741 int arg2 ;
35742 wxString result;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 char *kwnames[] = {
35746 (char *) "self",(char *) "id", NULL
35747 };
35748
35749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35751 if (SWIG_arg_fail(1)) SWIG_fail;
35752 {
35753 arg2 = (int)(SWIG_As_int(obj1));
35754 if (SWIG_arg_fail(2)) SWIG_fail;
35755 }
35756 {
35757 PyThreadState* __tstate = wxPyBeginAllowThreads();
35758 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35759
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 {
35764 #if wxUSE_UNICODE
35765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35766 #else
35767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35768 #endif
35769 }
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj;
35778 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35779 wxFrame *result;
35780 PyObject * obj0 = 0 ;
35781 char *kwnames[] = {
35782 (char *) "self", NULL
35783 };
35784
35785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35787 if (SWIG_arg_fail(1)) SWIG_fail;
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35791
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 {
35796 resultobj = wxPyMake_wxObject(result, 0);
35797 }
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35805 PyObject *resultobj;
35806 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35807 bool result;
35808 PyObject * obj0 = 0 ;
35809 char *kwnames[] = {
35810 (char *) "self", NULL
35811 };
35812
35813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35815 if (SWIG_arg_fail(1)) SWIG_fail;
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35819
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 {
35824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35825 }
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35833 PyObject *resultobj;
35834 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35835 wxFrame *arg2 = (wxFrame *) 0 ;
35836 PyObject * obj0 = 0 ;
35837 PyObject * obj1 = 0 ;
35838 char *kwnames[] = {
35839 (char *) "self",(char *) "frame", NULL
35840 };
35841
35842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35844 if (SWIG_arg_fail(1)) SWIG_fail;
35845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35846 if (SWIG_arg_fail(2)) SWIG_fail;
35847 {
35848 PyThreadState* __tstate = wxPyBeginAllowThreads();
35849 (arg1)->Attach(arg2);
35850
35851 wxPyEndAllowThreads(__tstate);
35852 if (PyErr_Occurred()) SWIG_fail;
35853 }
35854 Py_INCREF(Py_None); resultobj = Py_None;
35855 return resultobj;
35856 fail:
35857 return NULL;
35858 }
35859
35860
35861 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35862 PyObject *resultobj;
35863 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35864 PyObject * obj0 = 0 ;
35865 char *kwnames[] = {
35866 (char *) "self", NULL
35867 };
35868
35869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35871 if (SWIG_arg_fail(1)) SWIG_fail;
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 (arg1)->Detach();
35875
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 Py_INCREF(Py_None); resultobj = Py_None;
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35887 PyObject *obj;
35888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35889 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35890 Py_INCREF(obj);
35891 return Py_BuildValue((char *)"");
35892 }
35893 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35894 PyObject *resultobj;
35895 wxMenu *arg1 = (wxMenu *) NULL ;
35896 int arg2 = (int) wxID_ANY ;
35897 wxString const &arg3_defvalue = wxPyEmptyString ;
35898 wxString *arg3 = (wxString *) &arg3_defvalue ;
35899 wxString const &arg4_defvalue = wxPyEmptyString ;
35900 wxString *arg4 = (wxString *) &arg4_defvalue ;
35901 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35902 wxMenu *arg6 = (wxMenu *) NULL ;
35903 wxMenuItem *result;
35904 bool temp3 = false ;
35905 bool temp4 = false ;
35906 PyObject * obj0 = 0 ;
35907 PyObject * obj1 = 0 ;
35908 PyObject * obj2 = 0 ;
35909 PyObject * obj3 = 0 ;
35910 PyObject * obj4 = 0 ;
35911 PyObject * obj5 = 0 ;
35912 char *kwnames[] = {
35913 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35914 };
35915
35916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35917 if (obj0) {
35918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35919 if (SWIG_arg_fail(1)) SWIG_fail;
35920 }
35921 if (obj1) {
35922 {
35923 arg2 = (int)(SWIG_As_int(obj1));
35924 if (SWIG_arg_fail(2)) SWIG_fail;
35925 }
35926 }
35927 if (obj2) {
35928 {
35929 arg3 = wxString_in_helper(obj2);
35930 if (arg3 == NULL) SWIG_fail;
35931 temp3 = true;
35932 }
35933 }
35934 if (obj3) {
35935 {
35936 arg4 = wxString_in_helper(obj3);
35937 if (arg4 == NULL) SWIG_fail;
35938 temp4 = true;
35939 }
35940 }
35941 if (obj4) {
35942 {
35943 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35944 if (SWIG_arg_fail(5)) SWIG_fail;
35945 }
35946 }
35947 if (obj5) {
35948 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35949 if (SWIG_arg_fail(6)) SWIG_fail;
35950 }
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35954
35955 wxPyEndAllowThreads(__tstate);
35956 if (PyErr_Occurred()) SWIG_fail;
35957 }
35958 {
35959 resultobj = wxPyMake_wxObject(result, 1);
35960 }
35961 {
35962 if (temp3)
35963 delete arg3;
35964 }
35965 {
35966 if (temp4)
35967 delete arg4;
35968 }
35969 return resultobj;
35970 fail:
35971 {
35972 if (temp3)
35973 delete arg3;
35974 }
35975 {
35976 if (temp4)
35977 delete arg4;
35978 }
35979 return NULL;
35980 }
35981
35982
35983 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35984 PyObject *resultobj;
35985 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35986 wxMenu *result;
35987 PyObject * obj0 = 0 ;
35988 char *kwnames[] = {
35989 (char *) "self", NULL
35990 };
35991
35992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35994 if (SWIG_arg_fail(1)) SWIG_fail;
35995 {
35996 PyThreadState* __tstate = wxPyBeginAllowThreads();
35997 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35998
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 {
36003 resultobj = wxPyMake_wxObject(result, 0);
36004 }
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36012 PyObject *resultobj;
36013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36014 wxMenu *arg2 = (wxMenu *) 0 ;
36015 PyObject * obj0 = 0 ;
36016 PyObject * obj1 = 0 ;
36017 char *kwnames[] = {
36018 (char *) "self",(char *) "menu", NULL
36019 };
36020
36021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36023 if (SWIG_arg_fail(1)) SWIG_fail;
36024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36025 if (SWIG_arg_fail(2)) SWIG_fail;
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 (arg1)->SetMenu(arg2);
36029
36030 wxPyEndAllowThreads(__tstate);
36031 if (PyErr_Occurred()) SWIG_fail;
36032 }
36033 Py_INCREF(Py_None); resultobj = Py_None;
36034 return resultobj;
36035 fail:
36036 return NULL;
36037 }
36038
36039
36040 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36041 PyObject *resultobj;
36042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36043 int arg2 ;
36044 PyObject * obj0 = 0 ;
36045 PyObject * obj1 = 0 ;
36046 char *kwnames[] = {
36047 (char *) "self",(char *) "id", NULL
36048 };
36049
36050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36052 if (SWIG_arg_fail(1)) SWIG_fail;
36053 {
36054 arg2 = (int)(SWIG_As_int(obj1));
36055 if (SWIG_arg_fail(2)) SWIG_fail;
36056 }
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 (arg1)->SetId(arg2);
36060
36061 wxPyEndAllowThreads(__tstate);
36062 if (PyErr_Occurred()) SWIG_fail;
36063 }
36064 Py_INCREF(Py_None); resultobj = Py_None;
36065 return resultobj;
36066 fail:
36067 return NULL;
36068 }
36069
36070
36071 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36072 PyObject *resultobj;
36073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36074 int result;
36075 PyObject * obj0 = 0 ;
36076 char *kwnames[] = {
36077 (char *) "self", NULL
36078 };
36079
36080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(1)) SWIG_fail;
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (int)((wxMenuItem const *)arg1)->GetId();
36086
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 {
36091 resultobj = SWIG_From_int((int)(result));
36092 }
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj;
36101 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36102 bool result;
36103 PyObject * obj0 = 0 ;
36104 char *kwnames[] = {
36105 (char *) "self", NULL
36106 };
36107
36108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36110 if (SWIG_arg_fail(1)) SWIG_fail;
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36114
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 {
36119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36120 }
36121 return resultobj;
36122 fail:
36123 return NULL;
36124 }
36125
36126
36127 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36128 PyObject *resultobj;
36129 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36130 wxString *arg2 = 0 ;
36131 bool temp2 = false ;
36132 PyObject * obj0 = 0 ;
36133 PyObject * obj1 = 0 ;
36134 char *kwnames[] = {
36135 (char *) "self",(char *) "str", NULL
36136 };
36137
36138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36140 if (SWIG_arg_fail(1)) SWIG_fail;
36141 {
36142 arg2 = wxString_in_helper(obj1);
36143 if (arg2 == NULL) SWIG_fail;
36144 temp2 = true;
36145 }
36146 {
36147 PyThreadState* __tstate = wxPyBeginAllowThreads();
36148 (arg1)->SetText((wxString const &)*arg2);
36149
36150 wxPyEndAllowThreads(__tstate);
36151 if (PyErr_Occurred()) SWIG_fail;
36152 }
36153 Py_INCREF(Py_None); resultobj = Py_None;
36154 {
36155 if (temp2)
36156 delete arg2;
36157 }
36158 return resultobj;
36159 fail:
36160 {
36161 if (temp2)
36162 delete arg2;
36163 }
36164 return NULL;
36165 }
36166
36167
36168 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36169 PyObject *resultobj;
36170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36171 wxString result;
36172 PyObject * obj0 = 0 ;
36173 char *kwnames[] = {
36174 (char *) "self", NULL
36175 };
36176
36177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36179 if (SWIG_arg_fail(1)) SWIG_fail;
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 result = ((wxMenuItem const *)arg1)->GetLabel();
36183
36184 wxPyEndAllowThreads(__tstate);
36185 if (PyErr_Occurred()) SWIG_fail;
36186 }
36187 {
36188 #if wxUSE_UNICODE
36189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36190 #else
36191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36192 #endif
36193 }
36194 return resultobj;
36195 fail:
36196 return NULL;
36197 }
36198
36199
36200 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36201 PyObject *resultobj;
36202 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36203 wxString *result;
36204 PyObject * obj0 = 0 ;
36205 char *kwnames[] = {
36206 (char *) "self", NULL
36207 };
36208
36209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36211 if (SWIG_arg_fail(1)) SWIG_fail;
36212 {
36213 PyThreadState* __tstate = wxPyBeginAllowThreads();
36214 {
36215 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36216 result = (wxString *) &_result_ref;
36217 }
36218
36219 wxPyEndAllowThreads(__tstate);
36220 if (PyErr_Occurred()) SWIG_fail;
36221 }
36222 {
36223 #if wxUSE_UNICODE
36224 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36225 #else
36226 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36227 #endif
36228 }
36229 return resultobj;
36230 fail:
36231 return NULL;
36232 }
36233
36234
36235 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36236 PyObject *resultobj;
36237 wxString *arg1 = 0 ;
36238 wxString result;
36239 bool temp1 = false ;
36240 PyObject * obj0 = 0 ;
36241 char *kwnames[] = {
36242 (char *) "text", NULL
36243 };
36244
36245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36246 {
36247 arg1 = wxString_in_helper(obj0);
36248 if (arg1 == NULL) SWIG_fail;
36249 temp1 = true;
36250 }
36251 {
36252 PyThreadState* __tstate = wxPyBeginAllowThreads();
36253 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36254
36255 wxPyEndAllowThreads(__tstate);
36256 if (PyErr_Occurred()) SWIG_fail;
36257 }
36258 {
36259 #if wxUSE_UNICODE
36260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36261 #else
36262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36263 #endif
36264 }
36265 {
36266 if (temp1)
36267 delete arg1;
36268 }
36269 return resultobj;
36270 fail:
36271 {
36272 if (temp1)
36273 delete arg1;
36274 }
36275 return NULL;
36276 }
36277
36278
36279 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36280 PyObject *resultobj;
36281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36282 wxItemKind result;
36283 PyObject * obj0 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36294
36295 wxPyEndAllowThreads(__tstate);
36296 if (PyErr_Occurred()) SWIG_fail;
36297 }
36298 resultobj = SWIG_From_int((result));
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36306 PyObject *resultobj;
36307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36308 wxItemKind arg2 ;
36309 PyObject * obj0 = 0 ;
36310 PyObject * obj1 = 0 ;
36311 char *kwnames[] = {
36312 (char *) "self",(char *) "kind", NULL
36313 };
36314
36315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36317 if (SWIG_arg_fail(1)) SWIG_fail;
36318 {
36319 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36320 if (SWIG_arg_fail(2)) SWIG_fail;
36321 }
36322 {
36323 PyThreadState* __tstate = wxPyBeginAllowThreads();
36324 (arg1)->SetKind((wxItemKind )arg2);
36325
36326 wxPyEndAllowThreads(__tstate);
36327 if (PyErr_Occurred()) SWIG_fail;
36328 }
36329 Py_INCREF(Py_None); resultobj = Py_None;
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj;
36338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36339 bool arg2 ;
36340 PyObject * obj0 = 0 ;
36341 PyObject * obj1 = 0 ;
36342 char *kwnames[] = {
36343 (char *) "self",(char *) "checkable", NULL
36344 };
36345
36346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36348 if (SWIG_arg_fail(1)) SWIG_fail;
36349 {
36350 arg2 = (bool)(SWIG_As_bool(obj1));
36351 if (SWIG_arg_fail(2)) SWIG_fail;
36352 }
36353 {
36354 PyThreadState* __tstate = wxPyBeginAllowThreads();
36355 (arg1)->SetCheckable(arg2);
36356
36357 wxPyEndAllowThreads(__tstate);
36358 if (PyErr_Occurred()) SWIG_fail;
36359 }
36360 Py_INCREF(Py_None); resultobj = Py_None;
36361 return resultobj;
36362 fail:
36363 return NULL;
36364 }
36365
36366
36367 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36368 PyObject *resultobj;
36369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36370 bool result;
36371 PyObject * obj0 = 0 ;
36372 char *kwnames[] = {
36373 (char *) "self", NULL
36374 };
36375
36376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36378 if (SWIG_arg_fail(1)) SWIG_fail;
36379 {
36380 PyThreadState* __tstate = wxPyBeginAllowThreads();
36381 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36382
36383 wxPyEndAllowThreads(__tstate);
36384 if (PyErr_Occurred()) SWIG_fail;
36385 }
36386 {
36387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36388 }
36389 return resultobj;
36390 fail:
36391 return NULL;
36392 }
36393
36394
36395 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36396 PyObject *resultobj;
36397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36398 bool result;
36399 PyObject * obj0 = 0 ;
36400 char *kwnames[] = {
36401 (char *) "self", NULL
36402 };
36403
36404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36406 if (SWIG_arg_fail(1)) SWIG_fail;
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36410
36411 wxPyEndAllowThreads(__tstate);
36412 if (PyErr_Occurred()) SWIG_fail;
36413 }
36414 {
36415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36416 }
36417 return resultobj;
36418 fail:
36419 return NULL;
36420 }
36421
36422
36423 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36424 PyObject *resultobj;
36425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36426 wxMenu *arg2 = (wxMenu *) 0 ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 char *kwnames[] = {
36430 (char *) "self",(char *) "menu", NULL
36431 };
36432
36433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36435 if (SWIG_arg_fail(1)) SWIG_fail;
36436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36437 if (SWIG_arg_fail(2)) SWIG_fail;
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 (arg1)->SetSubMenu(arg2);
36441
36442 wxPyEndAllowThreads(__tstate);
36443 if (PyErr_Occurred()) SWIG_fail;
36444 }
36445 Py_INCREF(Py_None); resultobj = Py_None;
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36453 PyObject *resultobj;
36454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36455 wxMenu *result;
36456 PyObject * obj0 = 0 ;
36457 char *kwnames[] = {
36458 (char *) "self", NULL
36459 };
36460
36461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36463 if (SWIG_arg_fail(1)) SWIG_fail;
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36467
36468 wxPyEndAllowThreads(__tstate);
36469 if (PyErr_Occurred()) SWIG_fail;
36470 }
36471 {
36472 resultobj = wxPyMake_wxObject(result, 0);
36473 }
36474 return resultobj;
36475 fail:
36476 return NULL;
36477 }
36478
36479
36480 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36481 PyObject *resultobj;
36482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36483 bool arg2 = (bool) true ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char *kwnames[] = {
36487 (char *) "self",(char *) "enable", NULL
36488 };
36489
36490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36492 if (SWIG_arg_fail(1)) SWIG_fail;
36493 if (obj1) {
36494 {
36495 arg2 = (bool)(SWIG_As_bool(obj1));
36496 if (SWIG_arg_fail(2)) SWIG_fail;
36497 }
36498 }
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 (arg1)->Enable(arg2);
36502
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 Py_INCREF(Py_None); resultobj = Py_None;
36507 return resultobj;
36508 fail:
36509 return NULL;
36510 }
36511
36512
36513 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36514 PyObject *resultobj;
36515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36516 bool result;
36517 PyObject * obj0 = 0 ;
36518 char *kwnames[] = {
36519 (char *) "self", NULL
36520 };
36521
36522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36524 if (SWIG_arg_fail(1)) SWIG_fail;
36525 {
36526 PyThreadState* __tstate = wxPyBeginAllowThreads();
36527 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36528
36529 wxPyEndAllowThreads(__tstate);
36530 if (PyErr_Occurred()) SWIG_fail;
36531 }
36532 {
36533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36534 }
36535 return resultobj;
36536 fail:
36537 return NULL;
36538 }
36539
36540
36541 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj;
36543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36544 bool arg2 = (bool) true ;
36545 PyObject * obj0 = 0 ;
36546 PyObject * obj1 = 0 ;
36547 char *kwnames[] = {
36548 (char *) "self",(char *) "check", NULL
36549 };
36550
36551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36553 if (SWIG_arg_fail(1)) SWIG_fail;
36554 if (obj1) {
36555 {
36556 arg2 = (bool)(SWIG_As_bool(obj1));
36557 if (SWIG_arg_fail(2)) SWIG_fail;
36558 }
36559 }
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 (arg1)->Check(arg2);
36563
36564 wxPyEndAllowThreads(__tstate);
36565 if (PyErr_Occurred()) SWIG_fail;
36566 }
36567 Py_INCREF(Py_None); resultobj = Py_None;
36568 return resultobj;
36569 fail:
36570 return NULL;
36571 }
36572
36573
36574 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36575 PyObject *resultobj;
36576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36577 bool result;
36578 PyObject * obj0 = 0 ;
36579 char *kwnames[] = {
36580 (char *) "self", NULL
36581 };
36582
36583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36585 if (SWIG_arg_fail(1)) SWIG_fail;
36586 {
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36589
36590 wxPyEndAllowThreads(__tstate);
36591 if (PyErr_Occurred()) SWIG_fail;
36592 }
36593 {
36594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36595 }
36596 return resultobj;
36597 fail:
36598 return NULL;
36599 }
36600
36601
36602 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36603 PyObject *resultobj;
36604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36605 PyObject * obj0 = 0 ;
36606 char *kwnames[] = {
36607 (char *) "self", NULL
36608 };
36609
36610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36612 if (SWIG_arg_fail(1)) SWIG_fail;
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 (arg1)->Toggle();
36616
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 Py_INCREF(Py_None); resultobj = Py_None;
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36628 PyObject *resultobj;
36629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36630 wxString *arg2 = 0 ;
36631 bool temp2 = false ;
36632 PyObject * obj0 = 0 ;
36633 PyObject * obj1 = 0 ;
36634 char *kwnames[] = {
36635 (char *) "self",(char *) "str", NULL
36636 };
36637
36638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36640 if (SWIG_arg_fail(1)) SWIG_fail;
36641 {
36642 arg2 = wxString_in_helper(obj1);
36643 if (arg2 == NULL) SWIG_fail;
36644 temp2 = true;
36645 }
36646 {
36647 PyThreadState* __tstate = wxPyBeginAllowThreads();
36648 (arg1)->SetHelp((wxString const &)*arg2);
36649
36650 wxPyEndAllowThreads(__tstate);
36651 if (PyErr_Occurred()) SWIG_fail;
36652 }
36653 Py_INCREF(Py_None); resultobj = Py_None;
36654 {
36655 if (temp2)
36656 delete arg2;
36657 }
36658 return resultobj;
36659 fail:
36660 {
36661 if (temp2)
36662 delete arg2;
36663 }
36664 return NULL;
36665 }
36666
36667
36668 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36669 PyObject *resultobj;
36670 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36671 wxString *result;
36672 PyObject * obj0 = 0 ;
36673 char *kwnames[] = {
36674 (char *) "self", NULL
36675 };
36676
36677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36679 if (SWIG_arg_fail(1)) SWIG_fail;
36680 {
36681 PyThreadState* __tstate = wxPyBeginAllowThreads();
36682 {
36683 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36684 result = (wxString *) &_result_ref;
36685 }
36686
36687 wxPyEndAllowThreads(__tstate);
36688 if (PyErr_Occurred()) SWIG_fail;
36689 }
36690 {
36691 #if wxUSE_UNICODE
36692 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36693 #else
36694 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36695 #endif
36696 }
36697 return resultobj;
36698 fail:
36699 return NULL;
36700 }
36701
36702
36703 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36704 PyObject *resultobj;
36705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36706 wxAcceleratorEntry *result;
36707 PyObject * obj0 = 0 ;
36708 char *kwnames[] = {
36709 (char *) "self", NULL
36710 };
36711
36712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36714 if (SWIG_arg_fail(1)) SWIG_fail;
36715 {
36716 PyThreadState* __tstate = wxPyBeginAllowThreads();
36717 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36718
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj;
36731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36732 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char *kwnames[] = {
36736 (char *) "self",(char *) "accel", NULL
36737 };
36738
36739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36741 if (SWIG_arg_fail(1)) SWIG_fail;
36742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36743 if (SWIG_arg_fail(2)) SWIG_fail;
36744 {
36745 PyThreadState* __tstate = wxPyBeginAllowThreads();
36746 (arg1)->SetAccel(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_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj;
36760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36761 wxFont *arg2 = 0 ;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char *kwnames[] = {
36765 (char *) "self",(char *) "font", NULL
36766 };
36767
36768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36770 if (SWIG_arg_fail(1)) SWIG_fail;
36771 {
36772 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36773 if (SWIG_arg_fail(2)) SWIG_fail;
36774 if (arg2 == NULL) {
36775 SWIG_null_ref("wxFont");
36776 }
36777 if (SWIG_arg_fail(2)) SWIG_fail;
36778 }
36779 {
36780 PyThreadState* __tstate = wxPyBeginAllowThreads();
36781 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36782
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 Py_INCREF(Py_None); resultobj = Py_None;
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36794 PyObject *resultobj;
36795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36796 wxFont result;
36797 PyObject * obj0 = 0 ;
36798 char *kwnames[] = {
36799 (char *) "self", NULL
36800 };
36801
36802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36804 if (SWIG_arg_fail(1)) SWIG_fail;
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 result = wxMenuItem_GetFont(arg1);
36808
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 wxFont * resultptr;
36814 resultptr = new wxFont((wxFont &)(result));
36815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36816 }
36817 return resultobj;
36818 fail:
36819 return NULL;
36820 }
36821
36822
36823 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36824 PyObject *resultobj;
36825 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36826 wxColour *arg2 = 0 ;
36827 wxColour temp2 ;
36828 PyObject * obj0 = 0 ;
36829 PyObject * obj1 = 0 ;
36830 char *kwnames[] = {
36831 (char *) "self",(char *) "colText", NULL
36832 };
36833
36834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36836 if (SWIG_arg_fail(1)) SWIG_fail;
36837 {
36838 arg2 = &temp2;
36839 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36840 }
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36844
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 Py_INCREF(Py_None); resultobj = Py_None;
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36856 PyObject *resultobj;
36857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36858 wxColour result;
36859 PyObject * obj0 = 0 ;
36860 char *kwnames[] = {
36861 (char *) "self", NULL
36862 };
36863
36864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36866 if (SWIG_arg_fail(1)) SWIG_fail;
36867 {
36868 PyThreadState* __tstate = wxPyBeginAllowThreads();
36869 result = wxMenuItem_GetTextColour(arg1);
36870
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 wxColour * resultptr;
36876 resultptr = new wxColour((wxColour &)(result));
36877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj;
36887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36888 wxColour *arg2 = 0 ;
36889 wxColour temp2 ;
36890 PyObject * obj0 = 0 ;
36891 PyObject * obj1 = 0 ;
36892 char *kwnames[] = {
36893 (char *) "self",(char *) "colBack", NULL
36894 };
36895
36896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36898 if (SWIG_arg_fail(1)) SWIG_fail;
36899 {
36900 arg2 = &temp2;
36901 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36902 }
36903 {
36904 PyThreadState* __tstate = wxPyBeginAllowThreads();
36905 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36906
36907 wxPyEndAllowThreads(__tstate);
36908 if (PyErr_Occurred()) SWIG_fail;
36909 }
36910 Py_INCREF(Py_None); resultobj = Py_None;
36911 return resultobj;
36912 fail:
36913 return NULL;
36914 }
36915
36916
36917 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36918 PyObject *resultobj;
36919 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36920 wxColour result;
36921 PyObject * obj0 = 0 ;
36922 char *kwnames[] = {
36923 (char *) "self", NULL
36924 };
36925
36926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36928 if (SWIG_arg_fail(1)) SWIG_fail;
36929 {
36930 PyThreadState* __tstate = wxPyBeginAllowThreads();
36931 result = wxMenuItem_GetBackgroundColour(arg1);
36932
36933 wxPyEndAllowThreads(__tstate);
36934 if (PyErr_Occurred()) SWIG_fail;
36935 }
36936 {
36937 wxColour * resultptr;
36938 resultptr = new wxColour((wxColour &)(result));
36939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj;
36949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36950 wxBitmap *arg2 = 0 ;
36951 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36952 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36953 PyObject * obj0 = 0 ;
36954 PyObject * obj1 = 0 ;
36955 PyObject * obj2 = 0 ;
36956 char *kwnames[] = {
36957 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36958 };
36959
36960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36962 if (SWIG_arg_fail(1)) SWIG_fail;
36963 {
36964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36965 if (SWIG_arg_fail(2)) SWIG_fail;
36966 if (arg2 == NULL) {
36967 SWIG_null_ref("wxBitmap");
36968 }
36969 if (SWIG_arg_fail(2)) SWIG_fail;
36970 }
36971 if (obj2) {
36972 {
36973 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36974 if (SWIG_arg_fail(3)) SWIG_fail;
36975 if (arg3 == NULL) {
36976 SWIG_null_ref("wxBitmap");
36977 }
36978 if (SWIG_arg_fail(3)) SWIG_fail;
36979 }
36980 }
36981 {
36982 PyThreadState* __tstate = wxPyBeginAllowThreads();
36983 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36984
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 Py_INCREF(Py_None); resultobj = Py_None;
36989 return resultobj;
36990 fail:
36991 return NULL;
36992 }
36993
36994
36995 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36996 PyObject *resultobj;
36997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36998 wxBitmap *arg2 = 0 ;
36999 PyObject * obj0 = 0 ;
37000 PyObject * obj1 = 0 ;
37001 char *kwnames[] = {
37002 (char *) "self",(char *) "bmpDisabled", NULL
37003 };
37004
37005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37007 if (SWIG_arg_fail(1)) SWIG_fail;
37008 {
37009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37010 if (SWIG_arg_fail(2)) SWIG_fail;
37011 if (arg2 == NULL) {
37012 SWIG_null_ref("wxBitmap");
37013 }
37014 if (SWIG_arg_fail(2)) SWIG_fail;
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37019
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 Py_INCREF(Py_None); resultobj = Py_None;
37024 return resultobj;
37025 fail:
37026 return NULL;
37027 }
37028
37029
37030 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37031 PyObject *resultobj;
37032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37033 wxBitmap *result;
37034 PyObject * obj0 = 0 ;
37035 char *kwnames[] = {
37036 (char *) "self", NULL
37037 };
37038
37039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37041 if (SWIG_arg_fail(1)) SWIG_fail;
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 {
37045 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37046 result = (wxBitmap *) &_result_ref;
37047 }
37048
37049 wxPyEndAllowThreads(__tstate);
37050 if (PyErr_Occurred()) SWIG_fail;
37051 }
37052 {
37053 wxBitmap* resultptr = new wxBitmap(*result);
37054 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37055 }
37056 return resultobj;
37057 fail:
37058 return NULL;
37059 }
37060
37061
37062 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37063 PyObject *resultobj;
37064 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37065 int arg2 ;
37066 PyObject * obj0 = 0 ;
37067 PyObject * obj1 = 0 ;
37068 char *kwnames[] = {
37069 (char *) "self",(char *) "nWidth", NULL
37070 };
37071
37072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37074 if (SWIG_arg_fail(1)) SWIG_fail;
37075 {
37076 arg2 = (int)(SWIG_As_int(obj1));
37077 if (SWIG_arg_fail(2)) SWIG_fail;
37078 }
37079 {
37080 PyThreadState* __tstate = wxPyBeginAllowThreads();
37081 wxMenuItem_SetMarginWidth(arg1,arg2);
37082
37083 wxPyEndAllowThreads(__tstate);
37084 if (PyErr_Occurred()) SWIG_fail;
37085 }
37086 Py_INCREF(Py_None); resultobj = Py_None;
37087 return resultobj;
37088 fail:
37089 return NULL;
37090 }
37091
37092
37093 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj;
37095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37096 int result;
37097 PyObject * obj0 = 0 ;
37098 char *kwnames[] = {
37099 (char *) "self", NULL
37100 };
37101
37102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37104 if (SWIG_arg_fail(1)) SWIG_fail;
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 result = (int)wxMenuItem_GetMarginWidth(arg1);
37108
37109 wxPyEndAllowThreads(__tstate);
37110 if (PyErr_Occurred()) SWIG_fail;
37111 }
37112 {
37113 resultobj = SWIG_From_int((int)(result));
37114 }
37115 return resultobj;
37116 fail:
37117 return NULL;
37118 }
37119
37120
37121 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37122 PyObject *resultobj;
37123 int result;
37124 char *kwnames[] = {
37125 NULL
37126 };
37127
37128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 result = (int)MenuItem_GetDefaultMarginWidth();
37132
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 {
37137 resultobj = SWIG_From_int((int)(result));
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37146 PyObject *resultobj;
37147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37148 bool result;
37149 PyObject * obj0 = 0 ;
37150 char *kwnames[] = {
37151 (char *) "self", NULL
37152 };
37153
37154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37156 if (SWIG_arg_fail(1)) SWIG_fail;
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37160
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37166 }
37167 return resultobj;
37168 fail:
37169 return NULL;
37170 }
37171
37172
37173 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37174 PyObject *resultobj;
37175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37176 bool arg2 = (bool) true ;
37177 PyObject * obj0 = 0 ;
37178 PyObject * obj1 = 0 ;
37179 char *kwnames[] = {
37180 (char *) "self",(char *) "ownerDrawn", NULL
37181 };
37182
37183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37185 if (SWIG_arg_fail(1)) SWIG_fail;
37186 if (obj1) {
37187 {
37188 arg2 = (bool)(SWIG_As_bool(obj1));
37189 if (SWIG_arg_fail(2)) SWIG_fail;
37190 }
37191 }
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37195
37196 wxPyEndAllowThreads(__tstate);
37197 if (PyErr_Occurred()) SWIG_fail;
37198 }
37199 Py_INCREF(Py_None); resultobj = Py_None;
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37207 PyObject *resultobj;
37208 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37209 PyObject * obj0 = 0 ;
37210 char *kwnames[] = {
37211 (char *) "self", NULL
37212 };
37213
37214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37216 if (SWIG_arg_fail(1)) SWIG_fail;
37217 {
37218 PyThreadState* __tstate = wxPyBeginAllowThreads();
37219 wxMenuItem_ResetOwnerDrawn(arg1);
37220
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 Py_INCREF(Py_None); resultobj = Py_None;
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37232 PyObject *resultobj;
37233 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37234 wxBitmap *arg2 = 0 ;
37235 PyObject * obj0 = 0 ;
37236 PyObject * obj1 = 0 ;
37237 char *kwnames[] = {
37238 (char *) "self",(char *) "bitmap", NULL
37239 };
37240
37241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37243 if (SWIG_arg_fail(1)) SWIG_fail;
37244 {
37245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37246 if (SWIG_arg_fail(2)) SWIG_fail;
37247 if (arg2 == NULL) {
37248 SWIG_null_ref("wxBitmap");
37249 }
37250 if (SWIG_arg_fail(2)) SWIG_fail;
37251 }
37252 {
37253 PyThreadState* __tstate = wxPyBeginAllowThreads();
37254 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37255
37256 wxPyEndAllowThreads(__tstate);
37257 if (PyErr_Occurred()) SWIG_fail;
37258 }
37259 Py_INCREF(Py_None); resultobj = Py_None;
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj;
37268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37269 wxBitmap *result;
37270 PyObject * obj0 = 0 ;
37271 char *kwnames[] = {
37272 (char *) "self", NULL
37273 };
37274
37275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37277 if (SWIG_arg_fail(1)) SWIG_fail;
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 {
37281 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37282 result = (wxBitmap *) &_result_ref;
37283 }
37284
37285 wxPyEndAllowThreads(__tstate);
37286 if (PyErr_Occurred()) SWIG_fail;
37287 }
37288 {
37289 wxBitmap* resultptr = new wxBitmap(*result);
37290 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37291 }
37292 return resultobj;
37293 fail:
37294 return NULL;
37295 }
37296
37297
37298 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37299 PyObject *obj;
37300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37301 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37302 Py_INCREF(obj);
37303 return Py_BuildValue((char *)"");
37304 }
37305 static int _wrap_ControlNameStr_set(PyObject *) {
37306 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37307 return 1;
37308 }
37309
37310
37311 static PyObject *_wrap_ControlNameStr_get(void) {
37312 PyObject *pyobj;
37313
37314 {
37315 #if wxUSE_UNICODE
37316 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37317 #else
37318 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37319 #endif
37320 }
37321 return pyobj;
37322 }
37323
37324
37325 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37326 PyObject *resultobj;
37327 wxWindow *arg1 = (wxWindow *) 0 ;
37328 int arg2 = (int) -1 ;
37329 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37330 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37331 wxSize const &arg4_defvalue = wxDefaultSize ;
37332 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37333 long arg5 = (long) 0 ;
37334 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37335 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37336 wxString const &arg7_defvalue = wxPyControlNameStr ;
37337 wxString *arg7 = (wxString *) &arg7_defvalue ;
37338 wxControl *result;
37339 wxPoint temp3 ;
37340 wxSize temp4 ;
37341 bool temp7 = false ;
37342 PyObject * obj0 = 0 ;
37343 PyObject * obj1 = 0 ;
37344 PyObject * obj2 = 0 ;
37345 PyObject * obj3 = 0 ;
37346 PyObject * obj4 = 0 ;
37347 PyObject * obj5 = 0 ;
37348 PyObject * obj6 = 0 ;
37349 char *kwnames[] = {
37350 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37351 };
37352
37353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37355 if (SWIG_arg_fail(1)) SWIG_fail;
37356 if (obj1) {
37357 {
37358 arg2 = (int)(SWIG_As_int(obj1));
37359 if (SWIG_arg_fail(2)) SWIG_fail;
37360 }
37361 }
37362 if (obj2) {
37363 {
37364 arg3 = &temp3;
37365 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37366 }
37367 }
37368 if (obj3) {
37369 {
37370 arg4 = &temp4;
37371 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37372 }
37373 }
37374 if (obj4) {
37375 {
37376 arg5 = (long)(SWIG_As_long(obj4));
37377 if (SWIG_arg_fail(5)) SWIG_fail;
37378 }
37379 }
37380 if (obj5) {
37381 {
37382 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37383 if (SWIG_arg_fail(6)) SWIG_fail;
37384 if (arg6 == NULL) {
37385 SWIG_null_ref("wxValidator");
37386 }
37387 if (SWIG_arg_fail(6)) SWIG_fail;
37388 }
37389 }
37390 if (obj6) {
37391 {
37392 arg7 = wxString_in_helper(obj6);
37393 if (arg7 == NULL) SWIG_fail;
37394 temp7 = true;
37395 }
37396 }
37397 {
37398 if (!wxPyCheckForApp()) SWIG_fail;
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37401
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37406 {
37407 if (temp7)
37408 delete arg7;
37409 }
37410 return resultobj;
37411 fail:
37412 {
37413 if (temp7)
37414 delete arg7;
37415 }
37416 return NULL;
37417 }
37418
37419
37420 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37421 PyObject *resultobj;
37422 wxControl *result;
37423 char *kwnames[] = {
37424 NULL
37425 };
37426
37427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37428 {
37429 if (!wxPyCheckForApp()) SWIG_fail;
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 result = (wxControl *)new wxControl();
37432
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj;
37445 wxControl *arg1 = (wxControl *) 0 ;
37446 wxWindow *arg2 = (wxWindow *) 0 ;
37447 int arg3 = (int) -1 ;
37448 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37449 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37450 wxSize const &arg5_defvalue = wxDefaultSize ;
37451 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37452 long arg6 = (long) 0 ;
37453 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37454 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37455 wxString const &arg8_defvalue = wxPyControlNameStr ;
37456 wxString *arg8 = (wxString *) &arg8_defvalue ;
37457 bool result;
37458 wxPoint temp4 ;
37459 wxSize temp5 ;
37460 bool temp8 = false ;
37461 PyObject * obj0 = 0 ;
37462 PyObject * obj1 = 0 ;
37463 PyObject * obj2 = 0 ;
37464 PyObject * obj3 = 0 ;
37465 PyObject * obj4 = 0 ;
37466 PyObject * obj5 = 0 ;
37467 PyObject * obj6 = 0 ;
37468 PyObject * obj7 = 0 ;
37469 char *kwnames[] = {
37470 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37471 };
37472
37473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37475 if (SWIG_arg_fail(1)) SWIG_fail;
37476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37477 if (SWIG_arg_fail(2)) SWIG_fail;
37478 if (obj2) {
37479 {
37480 arg3 = (int)(SWIG_As_int(obj2));
37481 if (SWIG_arg_fail(3)) SWIG_fail;
37482 }
37483 }
37484 if (obj3) {
37485 {
37486 arg4 = &temp4;
37487 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37488 }
37489 }
37490 if (obj4) {
37491 {
37492 arg5 = &temp5;
37493 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37494 }
37495 }
37496 if (obj5) {
37497 {
37498 arg6 = (long)(SWIG_As_long(obj5));
37499 if (SWIG_arg_fail(6)) SWIG_fail;
37500 }
37501 }
37502 if (obj6) {
37503 {
37504 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37505 if (SWIG_arg_fail(7)) SWIG_fail;
37506 if (arg7 == NULL) {
37507 SWIG_null_ref("wxValidator");
37508 }
37509 if (SWIG_arg_fail(7)) SWIG_fail;
37510 }
37511 }
37512 if (obj7) {
37513 {
37514 arg8 = wxString_in_helper(obj7);
37515 if (arg8 == NULL) SWIG_fail;
37516 temp8 = true;
37517 }
37518 }
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37522
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 {
37527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37528 }
37529 {
37530 if (temp8)
37531 delete arg8;
37532 }
37533 return resultobj;
37534 fail:
37535 {
37536 if (temp8)
37537 delete arg8;
37538 }
37539 return NULL;
37540 }
37541
37542
37543 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37544 PyObject *resultobj;
37545 wxControl *arg1 = (wxControl *) 0 ;
37546 wxCommandEvent *arg2 = 0 ;
37547 PyObject * obj0 = 0 ;
37548 PyObject * obj1 = 0 ;
37549 char *kwnames[] = {
37550 (char *) "self",(char *) "event", NULL
37551 };
37552
37553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37555 if (SWIG_arg_fail(1)) SWIG_fail;
37556 {
37557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37558 if (SWIG_arg_fail(2)) SWIG_fail;
37559 if (arg2 == NULL) {
37560 SWIG_null_ref("wxCommandEvent");
37561 }
37562 if (SWIG_arg_fail(2)) SWIG_fail;
37563 }
37564 {
37565 PyThreadState* __tstate = wxPyBeginAllowThreads();
37566 (arg1)->Command(*arg2);
37567
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 Py_INCREF(Py_None); resultobj = Py_None;
37572 return resultobj;
37573 fail:
37574 return NULL;
37575 }
37576
37577
37578 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37579 PyObject *resultobj;
37580 wxControl *arg1 = (wxControl *) 0 ;
37581 wxString result;
37582 PyObject * obj0 = 0 ;
37583 char *kwnames[] = {
37584 (char *) "self", NULL
37585 };
37586
37587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37589 if (SWIG_arg_fail(1)) SWIG_fail;
37590 {
37591 PyThreadState* __tstate = wxPyBeginAllowThreads();
37592 result = (arg1)->GetLabel();
37593
37594 wxPyEndAllowThreads(__tstate);
37595 if (PyErr_Occurred()) SWIG_fail;
37596 }
37597 {
37598 #if wxUSE_UNICODE
37599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37600 #else
37601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37602 #endif
37603 }
37604 return resultobj;
37605 fail:
37606 return NULL;
37607 }
37608
37609
37610 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37611 PyObject *resultobj;
37612 wxControl *arg1 = (wxControl *) 0 ;
37613 wxString *arg2 = 0 ;
37614 bool temp2 = false ;
37615 PyObject * obj0 = 0 ;
37616 PyObject * obj1 = 0 ;
37617 char *kwnames[] = {
37618 (char *) "self",(char *) "label", NULL
37619 };
37620
37621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37623 if (SWIG_arg_fail(1)) SWIG_fail;
37624 {
37625 arg2 = wxString_in_helper(obj1);
37626 if (arg2 == NULL) SWIG_fail;
37627 temp2 = true;
37628 }
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 (arg1)->SetLabel((wxString const &)*arg2);
37632
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 Py_INCREF(Py_None); resultobj = Py_None;
37637 {
37638 if (temp2)
37639 delete arg2;
37640 }
37641 return resultobj;
37642 fail:
37643 {
37644 if (temp2)
37645 delete arg2;
37646 }
37647 return NULL;
37648 }
37649
37650
37651 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37652 PyObject *resultobj;
37653 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37654 wxVisualAttributes result;
37655 PyObject * obj0 = 0 ;
37656 char *kwnames[] = {
37657 (char *) "variant", NULL
37658 };
37659
37660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37661 if (obj0) {
37662 {
37663 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37664 if (SWIG_arg_fail(1)) SWIG_fail;
37665 }
37666 }
37667 {
37668 if (!wxPyCheckForApp()) SWIG_fail;
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37671
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 {
37676 wxVisualAttributes * resultptr;
37677 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37679 }
37680 return resultobj;
37681 fail:
37682 return NULL;
37683 }
37684
37685
37686 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37687 PyObject *obj;
37688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37689 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37690 Py_INCREF(obj);
37691 return Py_BuildValue((char *)"");
37692 }
37693 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37694 PyObject *resultobj;
37695 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37696 wxString *arg2 = 0 ;
37697 PyObject *arg3 = (PyObject *) NULL ;
37698 int result;
37699 bool temp2 = false ;
37700 PyObject * obj0 = 0 ;
37701 PyObject * obj1 = 0 ;
37702 PyObject * obj2 = 0 ;
37703 char *kwnames[] = {
37704 (char *) "self",(char *) "item",(char *) "clientData", NULL
37705 };
37706
37707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37709 if (SWIG_arg_fail(1)) SWIG_fail;
37710 {
37711 arg2 = wxString_in_helper(obj1);
37712 if (arg2 == NULL) SWIG_fail;
37713 temp2 = true;
37714 }
37715 if (obj2) {
37716 arg3 = obj2;
37717 }
37718 {
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 resultobj = SWIG_From_int((int)(result));
37727 }
37728 {
37729 if (temp2)
37730 delete arg2;
37731 }
37732 return resultobj;
37733 fail:
37734 {
37735 if (temp2)
37736 delete arg2;
37737 }
37738 return NULL;
37739 }
37740
37741
37742 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37743 PyObject *resultobj;
37744 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37745 wxArrayString *arg2 = 0 ;
37746 bool temp2 = false ;
37747 PyObject * obj0 = 0 ;
37748 PyObject * obj1 = 0 ;
37749 char *kwnames[] = {
37750 (char *) "self",(char *) "strings", NULL
37751 };
37752
37753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37755 if (SWIG_arg_fail(1)) SWIG_fail;
37756 {
37757 if (! PySequence_Check(obj1)) {
37758 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37759 SWIG_fail;
37760 }
37761 arg2 = new wxArrayString;
37762 temp2 = true;
37763 int i, len=PySequence_Length(obj1);
37764 for (i=0; i<len; i++) {
37765 PyObject* item = PySequence_GetItem(obj1, i);
37766 #if wxUSE_UNICODE
37767 PyObject* str = PyObject_Unicode(item);
37768 #else
37769 PyObject* str = PyObject_Str(item);
37770 #endif
37771 if (PyErr_Occurred()) SWIG_fail;
37772 arg2->Add(Py2wxString(str));
37773 Py_DECREF(item);
37774 Py_DECREF(str);
37775 }
37776 }
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 (arg1)->Append((wxArrayString const &)*arg2);
37780
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 Py_INCREF(Py_None); resultobj = Py_None;
37785 {
37786 if (temp2) delete arg2;
37787 }
37788 return resultobj;
37789 fail:
37790 {
37791 if (temp2) delete arg2;
37792 }
37793 return NULL;
37794 }
37795
37796
37797 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37798 PyObject *resultobj;
37799 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37800 wxString *arg2 = 0 ;
37801 int arg3 ;
37802 PyObject *arg4 = (PyObject *) NULL ;
37803 int result;
37804 bool temp2 = false ;
37805 PyObject * obj0 = 0 ;
37806 PyObject * obj1 = 0 ;
37807 PyObject * obj2 = 0 ;
37808 PyObject * obj3 = 0 ;
37809 char *kwnames[] = {
37810 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37811 };
37812
37813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37815 if (SWIG_arg_fail(1)) SWIG_fail;
37816 {
37817 arg2 = wxString_in_helper(obj1);
37818 if (arg2 == NULL) SWIG_fail;
37819 temp2 = true;
37820 }
37821 {
37822 arg3 = (int)(SWIG_As_int(obj2));
37823 if (SWIG_arg_fail(3)) SWIG_fail;
37824 }
37825 if (obj3) {
37826 arg4 = obj3;
37827 }
37828 {
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37831
37832 wxPyEndAllowThreads(__tstate);
37833 if (PyErr_Occurred()) SWIG_fail;
37834 }
37835 {
37836 resultobj = SWIG_From_int((int)(result));
37837 }
37838 {
37839 if (temp2)
37840 delete arg2;
37841 }
37842 return resultobj;
37843 fail:
37844 {
37845 if (temp2)
37846 delete arg2;
37847 }
37848 return NULL;
37849 }
37850
37851
37852 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj;
37854 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37855 PyObject * obj0 = 0 ;
37856 char *kwnames[] = {
37857 (char *) "self", NULL
37858 };
37859
37860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37862 if (SWIG_arg_fail(1)) SWIG_fail;
37863 {
37864 PyThreadState* __tstate = wxPyBeginAllowThreads();
37865 (arg1)->Clear();
37866
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 Py_INCREF(Py_None); resultobj = Py_None;
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj;
37879 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37880 int arg2 ;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 char *kwnames[] = {
37884 (char *) "self",(char *) "n", NULL
37885 };
37886
37887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37889 if (SWIG_arg_fail(1)) SWIG_fail;
37890 {
37891 arg2 = (int)(SWIG_As_int(obj1));
37892 if (SWIG_arg_fail(2)) SWIG_fail;
37893 }
37894 {
37895 PyThreadState* __tstate = wxPyBeginAllowThreads();
37896 (arg1)->Delete(arg2);
37897
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 Py_INCREF(Py_None); resultobj = Py_None;
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37909 PyObject *resultobj;
37910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37911 int arg2 ;
37912 PyObject *result;
37913 PyObject * obj0 = 0 ;
37914 PyObject * obj1 = 0 ;
37915 char *kwnames[] = {
37916 (char *) "self",(char *) "n", NULL
37917 };
37918
37919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37921 if (SWIG_arg_fail(1)) SWIG_fail;
37922 {
37923 arg2 = (int)(SWIG_As_int(obj1));
37924 if (SWIG_arg_fail(2)) SWIG_fail;
37925 }
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37929
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 resultobj = result;
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37941 PyObject *resultobj;
37942 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37943 int arg2 ;
37944 PyObject *arg3 = (PyObject *) 0 ;
37945 PyObject * obj0 = 0 ;
37946 PyObject * obj1 = 0 ;
37947 PyObject * obj2 = 0 ;
37948 char *kwnames[] = {
37949 (char *) "self",(char *) "n",(char *) "clientData", NULL
37950 };
37951
37952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37954 if (SWIG_arg_fail(1)) SWIG_fail;
37955 {
37956 arg2 = (int)(SWIG_As_int(obj1));
37957 if (SWIG_arg_fail(2)) SWIG_fail;
37958 }
37959 arg3 = obj2;
37960 {
37961 PyThreadState* __tstate = wxPyBeginAllowThreads();
37962 wxItemContainer_SetClientData(arg1,arg2,arg3);
37963
37964 wxPyEndAllowThreads(__tstate);
37965 if (PyErr_Occurred()) SWIG_fail;
37966 }
37967 Py_INCREF(Py_None); resultobj = Py_None;
37968 return resultobj;
37969 fail:
37970 return NULL;
37971 }
37972
37973
37974 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37975 PyObject *resultobj;
37976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37977 int result;
37978 PyObject * obj0 = 0 ;
37979 char *kwnames[] = {
37980 (char *) "self", NULL
37981 };
37982
37983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37985 if (SWIG_arg_fail(1)) SWIG_fail;
37986 {
37987 PyThreadState* __tstate = wxPyBeginAllowThreads();
37988 result = (int)((wxItemContainer const *)arg1)->GetCount();
37989
37990 wxPyEndAllowThreads(__tstate);
37991 if (PyErr_Occurred()) SWIG_fail;
37992 }
37993 {
37994 resultobj = SWIG_From_int((int)(result));
37995 }
37996 return resultobj;
37997 fail:
37998 return NULL;
37999 }
38000
38001
38002 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38003 PyObject *resultobj;
38004 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38005 bool result;
38006 PyObject * obj0 = 0 ;
38007 char *kwnames[] = {
38008 (char *) "self", NULL
38009 };
38010
38011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38013 if (SWIG_arg_fail(1)) SWIG_fail;
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38017
38018 wxPyEndAllowThreads(__tstate);
38019 if (PyErr_Occurred()) SWIG_fail;
38020 }
38021 {
38022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38023 }
38024 return resultobj;
38025 fail:
38026 return NULL;
38027 }
38028
38029
38030 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38031 PyObject *resultobj;
38032 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38033 int arg2 ;
38034 wxString result;
38035 PyObject * obj0 = 0 ;
38036 PyObject * obj1 = 0 ;
38037 char *kwnames[] = {
38038 (char *) "self",(char *) "n", NULL
38039 };
38040
38041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38043 if (SWIG_arg_fail(1)) SWIG_fail;
38044 {
38045 arg2 = (int)(SWIG_As_int(obj1));
38046 if (SWIG_arg_fail(2)) SWIG_fail;
38047 }
38048 {
38049 PyThreadState* __tstate = wxPyBeginAllowThreads();
38050 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38051
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 {
38056 #if wxUSE_UNICODE
38057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38058 #else
38059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38060 #endif
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj;
38070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38071 wxArrayString result;
38072 PyObject * obj0 = 0 ;
38073 char *kwnames[] = {
38074 (char *) "self", NULL
38075 };
38076
38077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38079 if (SWIG_arg_fail(1)) SWIG_fail;
38080 {
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 result = ((wxItemContainer const *)arg1)->GetStrings();
38083
38084 wxPyEndAllowThreads(__tstate);
38085 if (PyErr_Occurred()) SWIG_fail;
38086 }
38087 {
38088 resultobj = wxArrayString2PyList_helper(result);
38089 }
38090 return resultobj;
38091 fail:
38092 return NULL;
38093 }
38094
38095
38096 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38097 PyObject *resultobj;
38098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38099 int arg2 ;
38100 wxString *arg3 = 0 ;
38101 bool temp3 = false ;
38102 PyObject * obj0 = 0 ;
38103 PyObject * obj1 = 0 ;
38104 PyObject * obj2 = 0 ;
38105 char *kwnames[] = {
38106 (char *) "self",(char *) "n",(char *) "s", NULL
38107 };
38108
38109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38111 if (SWIG_arg_fail(1)) SWIG_fail;
38112 {
38113 arg2 = (int)(SWIG_As_int(obj1));
38114 if (SWIG_arg_fail(2)) SWIG_fail;
38115 }
38116 {
38117 arg3 = wxString_in_helper(obj2);
38118 if (arg3 == NULL) SWIG_fail;
38119 temp3 = true;
38120 }
38121 {
38122 PyThreadState* __tstate = wxPyBeginAllowThreads();
38123 (arg1)->SetString(arg2,(wxString const &)*arg3);
38124
38125 wxPyEndAllowThreads(__tstate);
38126 if (PyErr_Occurred()) SWIG_fail;
38127 }
38128 Py_INCREF(Py_None); resultobj = Py_None;
38129 {
38130 if (temp3)
38131 delete arg3;
38132 }
38133 return resultobj;
38134 fail:
38135 {
38136 if (temp3)
38137 delete arg3;
38138 }
38139 return NULL;
38140 }
38141
38142
38143 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38144 PyObject *resultobj;
38145 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38146 wxString *arg2 = 0 ;
38147 int result;
38148 bool temp2 = false ;
38149 PyObject * obj0 = 0 ;
38150 PyObject * obj1 = 0 ;
38151 char *kwnames[] = {
38152 (char *) "self",(char *) "s", NULL
38153 };
38154
38155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38157 if (SWIG_arg_fail(1)) SWIG_fail;
38158 {
38159 arg2 = wxString_in_helper(obj1);
38160 if (arg2 == NULL) SWIG_fail;
38161 temp2 = true;
38162 }
38163 {
38164 PyThreadState* __tstate = wxPyBeginAllowThreads();
38165 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38166
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = SWIG_From_int((int)(result));
38172 }
38173 {
38174 if (temp2)
38175 delete arg2;
38176 }
38177 return resultobj;
38178 fail:
38179 {
38180 if (temp2)
38181 delete arg2;
38182 }
38183 return NULL;
38184 }
38185
38186
38187 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj;
38189 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38190 int arg2 ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 char *kwnames[] = {
38194 (char *) "self",(char *) "n", NULL
38195 };
38196
38197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38199 if (SWIG_arg_fail(1)) SWIG_fail;
38200 {
38201 arg2 = (int)(SWIG_As_int(obj1));
38202 if (SWIG_arg_fail(2)) SWIG_fail;
38203 }
38204 {
38205 PyThreadState* __tstate = wxPyBeginAllowThreads();
38206 (arg1)->SetSelection(arg2);
38207
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 Py_INCREF(Py_None); resultobj = Py_None;
38212 return resultobj;
38213 fail:
38214 return NULL;
38215 }
38216
38217
38218 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38219 PyObject *resultobj;
38220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38221 int result;
38222 PyObject * obj0 = 0 ;
38223 char *kwnames[] = {
38224 (char *) "self", NULL
38225 };
38226
38227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38229 if (SWIG_arg_fail(1)) SWIG_fail;
38230 {
38231 PyThreadState* __tstate = wxPyBeginAllowThreads();
38232 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38233
38234 wxPyEndAllowThreads(__tstate);
38235 if (PyErr_Occurred()) SWIG_fail;
38236 }
38237 {
38238 resultobj = SWIG_From_int((int)(result));
38239 }
38240 return resultobj;
38241 fail:
38242 return NULL;
38243 }
38244
38245
38246 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38247 PyObject *resultobj;
38248 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38249 wxString *arg2 = 0 ;
38250 bool result;
38251 bool temp2 = false ;
38252 PyObject * obj0 = 0 ;
38253 PyObject * obj1 = 0 ;
38254 char *kwnames[] = {
38255 (char *) "self",(char *) "s", NULL
38256 };
38257
38258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38260 if (SWIG_arg_fail(1)) SWIG_fail;
38261 {
38262 arg2 = wxString_in_helper(obj1);
38263 if (arg2 == NULL) SWIG_fail;
38264 temp2 = true;
38265 }
38266 {
38267 PyThreadState* __tstate = wxPyBeginAllowThreads();
38268 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38269
38270 wxPyEndAllowThreads(__tstate);
38271 if (PyErr_Occurred()) SWIG_fail;
38272 }
38273 {
38274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38275 }
38276 {
38277 if (temp2)
38278 delete arg2;
38279 }
38280 return resultobj;
38281 fail:
38282 {
38283 if (temp2)
38284 delete arg2;
38285 }
38286 return NULL;
38287 }
38288
38289
38290 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38291 PyObject *resultobj;
38292 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38293 wxString result;
38294 PyObject * obj0 = 0 ;
38295 char *kwnames[] = {
38296 (char *) "self", NULL
38297 };
38298
38299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38301 if (SWIG_arg_fail(1)) SWIG_fail;
38302 {
38303 PyThreadState* __tstate = wxPyBeginAllowThreads();
38304 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38305
38306 wxPyEndAllowThreads(__tstate);
38307 if (PyErr_Occurred()) SWIG_fail;
38308 }
38309 {
38310 #if wxUSE_UNICODE
38311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38312 #else
38313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38314 #endif
38315 }
38316 return resultobj;
38317 fail:
38318 return NULL;
38319 }
38320
38321
38322 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38323 PyObject *resultobj;
38324 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38325 int arg2 ;
38326 PyObject * obj0 = 0 ;
38327 PyObject * obj1 = 0 ;
38328 char *kwnames[] = {
38329 (char *) "self",(char *) "n", NULL
38330 };
38331
38332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38334 if (SWIG_arg_fail(1)) SWIG_fail;
38335 {
38336 arg2 = (int)(SWIG_As_int(obj1));
38337 if (SWIG_arg_fail(2)) SWIG_fail;
38338 }
38339 {
38340 PyThreadState* __tstate = wxPyBeginAllowThreads();
38341 (arg1)->Select(arg2);
38342
38343 wxPyEndAllowThreads(__tstate);
38344 if (PyErr_Occurred()) SWIG_fail;
38345 }
38346 Py_INCREF(Py_None); resultobj = Py_None;
38347 return resultobj;
38348 fail:
38349 return NULL;
38350 }
38351
38352
38353 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38354 PyObject *obj;
38355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38356 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38357 Py_INCREF(obj);
38358 return Py_BuildValue((char *)"");
38359 }
38360 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38361 PyObject *obj;
38362 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38363 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38364 Py_INCREF(obj);
38365 return Py_BuildValue((char *)"");
38366 }
38367 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38368 PyObject *resultobj;
38369 wxSizerItem *result;
38370 char *kwnames[] = {
38371 NULL
38372 };
38373
38374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38375 {
38376 PyThreadState* __tstate = wxPyBeginAllowThreads();
38377 result = (wxSizerItem *)new wxSizerItem();
38378
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38390 PyObject *resultobj;
38391 wxWindow *arg1 = (wxWindow *) 0 ;
38392 int arg2 ;
38393 int arg3 ;
38394 int arg4 ;
38395 PyObject *arg5 = (PyObject *) NULL ;
38396 wxSizerItem *result;
38397 PyObject * obj0 = 0 ;
38398 PyObject * obj1 = 0 ;
38399 PyObject * obj2 = 0 ;
38400 PyObject * obj3 = 0 ;
38401 PyObject * obj4 = 0 ;
38402 char *kwnames[] = {
38403 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38404 };
38405
38406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38408 if (SWIG_arg_fail(1)) SWIG_fail;
38409 {
38410 arg2 = (int)(SWIG_As_int(obj1));
38411 if (SWIG_arg_fail(2)) SWIG_fail;
38412 }
38413 {
38414 arg3 = (int)(SWIG_As_int(obj2));
38415 if (SWIG_arg_fail(3)) SWIG_fail;
38416 }
38417 {
38418 arg4 = (int)(SWIG_As_int(obj3));
38419 if (SWIG_arg_fail(4)) SWIG_fail;
38420 }
38421 if (obj4) {
38422 arg5 = obj4;
38423 }
38424 {
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38427
38428 wxPyEndAllowThreads(__tstate);
38429 if (PyErr_Occurred()) SWIG_fail;
38430 }
38431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38432 return resultobj;
38433 fail:
38434 return NULL;
38435 }
38436
38437
38438 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38439 PyObject *resultobj;
38440 int arg1 ;
38441 int arg2 ;
38442 int arg3 ;
38443 int arg4 ;
38444 int arg5 ;
38445 PyObject *arg6 = (PyObject *) NULL ;
38446 wxSizerItem *result;
38447 PyObject * obj0 = 0 ;
38448 PyObject * obj1 = 0 ;
38449 PyObject * obj2 = 0 ;
38450 PyObject * obj3 = 0 ;
38451 PyObject * obj4 = 0 ;
38452 PyObject * obj5 = 0 ;
38453 char *kwnames[] = {
38454 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38455 };
38456
38457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38458 {
38459 arg1 = (int)(SWIG_As_int(obj0));
38460 if (SWIG_arg_fail(1)) SWIG_fail;
38461 }
38462 {
38463 arg2 = (int)(SWIG_As_int(obj1));
38464 if (SWIG_arg_fail(2)) SWIG_fail;
38465 }
38466 {
38467 arg3 = (int)(SWIG_As_int(obj2));
38468 if (SWIG_arg_fail(3)) SWIG_fail;
38469 }
38470 {
38471 arg4 = (int)(SWIG_As_int(obj3));
38472 if (SWIG_arg_fail(4)) SWIG_fail;
38473 }
38474 {
38475 arg5 = (int)(SWIG_As_int(obj4));
38476 if (SWIG_arg_fail(5)) SWIG_fail;
38477 }
38478 if (obj5) {
38479 arg6 = obj5;
38480 }
38481 {
38482 PyThreadState* __tstate = wxPyBeginAllowThreads();
38483 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38484
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38496 PyObject *resultobj;
38497 wxSizer *arg1 = (wxSizer *) 0 ;
38498 int arg2 ;
38499 int arg3 ;
38500 int arg4 ;
38501 PyObject *arg5 = (PyObject *) NULL ;
38502 wxSizerItem *result;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 PyObject * obj2 = 0 ;
38506 PyObject * obj3 = 0 ;
38507 PyObject * obj4 = 0 ;
38508 char *kwnames[] = {
38509 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38510 };
38511
38512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38514 if (SWIG_arg_fail(1)) SWIG_fail;
38515 {
38516 arg2 = (int)(SWIG_As_int(obj1));
38517 if (SWIG_arg_fail(2)) SWIG_fail;
38518 }
38519 {
38520 arg3 = (int)(SWIG_As_int(obj2));
38521 if (SWIG_arg_fail(3)) SWIG_fail;
38522 }
38523 {
38524 arg4 = (int)(SWIG_As_int(obj3));
38525 if (SWIG_arg_fail(4)) SWIG_fail;
38526 }
38527 if (obj4) {
38528 arg5 = obj4;
38529 }
38530 {
38531 PyThreadState* __tstate = wxPyBeginAllowThreads();
38532 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38533
38534 wxPyEndAllowThreads(__tstate);
38535 if (PyErr_Occurred()) SWIG_fail;
38536 }
38537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38538 return resultobj;
38539 fail:
38540 return NULL;
38541 }
38542
38543
38544 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38545 PyObject *resultobj;
38546 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38547 PyObject * obj0 = 0 ;
38548 char *kwnames[] = {
38549 (char *) "self", NULL
38550 };
38551
38552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38554 if (SWIG_arg_fail(1)) SWIG_fail;
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 (arg1)->DeleteWindows();
38558
38559 wxPyEndAllowThreads(__tstate);
38560 if (PyErr_Occurred()) SWIG_fail;
38561 }
38562 Py_INCREF(Py_None); resultobj = Py_None;
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38570 PyObject *resultobj;
38571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38572 PyObject * obj0 = 0 ;
38573 char *kwnames[] = {
38574 (char *) "self", NULL
38575 };
38576
38577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38579 if (SWIG_arg_fail(1)) SWIG_fail;
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 (arg1)->DetachSizer();
38583
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 Py_INCREF(Py_None); resultobj = Py_None;
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj;
38596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38597 wxSize result;
38598 PyObject * obj0 = 0 ;
38599 char *kwnames[] = {
38600 (char *) "self", NULL
38601 };
38602
38603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38605 if (SWIG_arg_fail(1)) SWIG_fail;
38606 {
38607 PyThreadState* __tstate = wxPyBeginAllowThreads();
38608 result = (arg1)->GetSize();
38609
38610 wxPyEndAllowThreads(__tstate);
38611 if (PyErr_Occurred()) SWIG_fail;
38612 }
38613 {
38614 wxSize * resultptr;
38615 resultptr = new wxSize((wxSize &)(result));
38616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38617 }
38618 return resultobj;
38619 fail:
38620 return NULL;
38621 }
38622
38623
38624 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj;
38626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38627 wxSize result;
38628 PyObject * obj0 = 0 ;
38629 char *kwnames[] = {
38630 (char *) "self", NULL
38631 };
38632
38633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38635 if (SWIG_arg_fail(1)) SWIG_fail;
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 result = (arg1)->CalcMin();
38639
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 {
38644 wxSize * resultptr;
38645 resultptr = new wxSize((wxSize &)(result));
38646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38647 }
38648 return resultobj;
38649 fail:
38650 return NULL;
38651 }
38652
38653
38654 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38655 PyObject *resultobj;
38656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38657 wxPoint arg2 ;
38658 wxSize arg3 ;
38659 PyObject * obj0 = 0 ;
38660 PyObject * obj1 = 0 ;
38661 PyObject * obj2 = 0 ;
38662 char *kwnames[] = {
38663 (char *) "self",(char *) "pos",(char *) "size", NULL
38664 };
38665
38666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38668 if (SWIG_arg_fail(1)) SWIG_fail;
38669 {
38670 wxPoint * argp;
38671 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38672 if (SWIG_arg_fail(2)) SWIG_fail;
38673 if (argp == NULL) {
38674 SWIG_null_ref("wxPoint");
38675 }
38676 if (SWIG_arg_fail(2)) SWIG_fail;
38677 arg2 = *argp;
38678 }
38679 {
38680 wxSize * argp;
38681 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38682 if (SWIG_arg_fail(3)) SWIG_fail;
38683 if (argp == NULL) {
38684 SWIG_null_ref("wxSize");
38685 }
38686 if (SWIG_arg_fail(3)) SWIG_fail;
38687 arg3 = *argp;
38688 }
38689 {
38690 PyThreadState* __tstate = wxPyBeginAllowThreads();
38691 (arg1)->SetDimension(arg2,arg3);
38692
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 Py_INCREF(Py_None); resultobj = Py_None;
38697 return resultobj;
38698 fail:
38699 return NULL;
38700 }
38701
38702
38703 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38704 PyObject *resultobj;
38705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38706 wxSize result;
38707 PyObject * obj0 = 0 ;
38708 char *kwnames[] = {
38709 (char *) "self", NULL
38710 };
38711
38712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38714 if (SWIG_arg_fail(1)) SWIG_fail;
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 result = (arg1)->GetMinSize();
38718
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 {
38723 wxSize * resultptr;
38724 resultptr = new wxSize((wxSize &)(result));
38725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38726 }
38727 return resultobj;
38728 fail:
38729 return NULL;
38730 }
38731
38732
38733 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38734 PyObject *resultobj;
38735 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38736 wxSize result;
38737 PyObject * obj0 = 0 ;
38738 char *kwnames[] = {
38739 (char *) "self", NULL
38740 };
38741
38742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38744 if (SWIG_arg_fail(1)) SWIG_fail;
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38748
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 {
38753 wxSize * resultptr;
38754 resultptr = new wxSize((wxSize &)(result));
38755 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38756 }
38757 return resultobj;
38758 fail:
38759 return NULL;
38760 }
38761
38762
38763 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38764 PyObject *resultobj;
38765 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38766 int arg2 ;
38767 int arg3 ;
38768 PyObject * obj0 = 0 ;
38769 PyObject * obj1 = 0 ;
38770 PyObject * obj2 = 0 ;
38771 char *kwnames[] = {
38772 (char *) "self",(char *) "x",(char *) "y", NULL
38773 };
38774
38775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38777 if (SWIG_arg_fail(1)) SWIG_fail;
38778 {
38779 arg2 = (int)(SWIG_As_int(obj1));
38780 if (SWIG_arg_fail(2)) SWIG_fail;
38781 }
38782 {
38783 arg3 = (int)(SWIG_As_int(obj2));
38784 if (SWIG_arg_fail(3)) SWIG_fail;
38785 }
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 (arg1)->SetInitSize(arg2,arg3);
38789
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 Py_INCREF(Py_None); resultobj = Py_None;
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38801 PyObject *resultobj;
38802 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38803 int arg2 ;
38804 int arg3 ;
38805 PyObject * obj0 = 0 ;
38806 PyObject * obj1 = 0 ;
38807 PyObject * obj2 = 0 ;
38808 char *kwnames[] = {
38809 (char *) "self",(char *) "width",(char *) "height", NULL
38810 };
38811
38812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38814 if (SWIG_arg_fail(1)) SWIG_fail;
38815 {
38816 arg2 = (int)(SWIG_As_int(obj1));
38817 if (SWIG_arg_fail(2)) SWIG_fail;
38818 }
38819 {
38820 arg3 = (int)(SWIG_As_int(obj2));
38821 if (SWIG_arg_fail(3)) SWIG_fail;
38822 }
38823 {
38824 PyThreadState* __tstate = wxPyBeginAllowThreads();
38825 (arg1)->SetRatio(arg2,arg3);
38826
38827 wxPyEndAllowThreads(__tstate);
38828 if (PyErr_Occurred()) SWIG_fail;
38829 }
38830 Py_INCREF(Py_None); resultobj = Py_None;
38831 return resultobj;
38832 fail:
38833 return NULL;
38834 }
38835
38836
38837 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38838 PyObject *resultobj;
38839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38840 wxSize *arg2 = 0 ;
38841 wxSize temp2 ;
38842 PyObject * obj0 = 0 ;
38843 PyObject * obj1 = 0 ;
38844 char *kwnames[] = {
38845 (char *) "self",(char *) "size", NULL
38846 };
38847
38848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38850 if (SWIG_arg_fail(1)) SWIG_fail;
38851 {
38852 arg2 = &temp2;
38853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38854 }
38855 {
38856 PyThreadState* __tstate = wxPyBeginAllowThreads();
38857 (arg1)->SetRatio((wxSize const &)*arg2);
38858
38859 wxPyEndAllowThreads(__tstate);
38860 if (PyErr_Occurred()) SWIG_fail;
38861 }
38862 Py_INCREF(Py_None); resultobj = Py_None;
38863 return resultobj;
38864 fail:
38865 return NULL;
38866 }
38867
38868
38869 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38870 PyObject *resultobj;
38871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38872 float arg2 ;
38873 PyObject * obj0 = 0 ;
38874 PyObject * obj1 = 0 ;
38875 char *kwnames[] = {
38876 (char *) "self",(char *) "ratio", NULL
38877 };
38878
38879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38881 if (SWIG_arg_fail(1)) SWIG_fail;
38882 {
38883 arg2 = (float)(SWIG_As_float(obj1));
38884 if (SWIG_arg_fail(2)) SWIG_fail;
38885 }
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 (arg1)->SetRatio(arg2);
38889
38890 wxPyEndAllowThreads(__tstate);
38891 if (PyErr_Occurred()) SWIG_fail;
38892 }
38893 Py_INCREF(Py_None); resultobj = Py_None;
38894 return resultobj;
38895 fail:
38896 return NULL;
38897 }
38898
38899
38900 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38901 PyObject *resultobj;
38902 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38903 float result;
38904 PyObject * obj0 = 0 ;
38905 char *kwnames[] = {
38906 (char *) "self", NULL
38907 };
38908
38909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38911 if (SWIG_arg_fail(1)) SWIG_fail;
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 result = (float)(arg1)->GetRatio();
38915
38916 wxPyEndAllowThreads(__tstate);
38917 if (PyErr_Occurred()) SWIG_fail;
38918 }
38919 {
38920 resultobj = SWIG_From_float((float)(result));
38921 }
38922 return resultobj;
38923 fail:
38924 return NULL;
38925 }
38926
38927
38928 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38929 PyObject *resultobj;
38930 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38931 wxRect result;
38932 PyObject * obj0 = 0 ;
38933 char *kwnames[] = {
38934 (char *) "self", NULL
38935 };
38936
38937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38939 if (SWIG_arg_fail(1)) SWIG_fail;
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 result = (arg1)->GetRect();
38943
38944 wxPyEndAllowThreads(__tstate);
38945 if (PyErr_Occurred()) SWIG_fail;
38946 }
38947 {
38948 wxRect * resultptr;
38949 resultptr = new wxRect((wxRect &)(result));
38950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38951 }
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38959 PyObject *resultobj;
38960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38961 bool result;
38962 PyObject * obj0 = 0 ;
38963 char *kwnames[] = {
38964 (char *) "self", NULL
38965 };
38966
38967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38969 if (SWIG_arg_fail(1)) SWIG_fail;
38970 {
38971 PyThreadState* __tstate = wxPyBeginAllowThreads();
38972 result = (bool)(arg1)->IsWindow();
38973
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 {
38978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38979 }
38980 return resultobj;
38981 fail:
38982 return NULL;
38983 }
38984
38985
38986 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38987 PyObject *resultobj;
38988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38989 bool result;
38990 PyObject * obj0 = 0 ;
38991 char *kwnames[] = {
38992 (char *) "self", NULL
38993 };
38994
38995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38997 if (SWIG_arg_fail(1)) SWIG_fail;
38998 {
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 result = (bool)(arg1)->IsSizer();
39001
39002 wxPyEndAllowThreads(__tstate);
39003 if (PyErr_Occurred()) SWIG_fail;
39004 }
39005 {
39006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39007 }
39008 return resultobj;
39009 fail:
39010 return NULL;
39011 }
39012
39013
39014 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39015 PyObject *resultobj;
39016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39017 bool result;
39018 PyObject * obj0 = 0 ;
39019 char *kwnames[] = {
39020 (char *) "self", NULL
39021 };
39022
39023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39025 if (SWIG_arg_fail(1)) SWIG_fail;
39026 {
39027 PyThreadState* __tstate = wxPyBeginAllowThreads();
39028 result = (bool)(arg1)->IsSpacer();
39029
39030 wxPyEndAllowThreads(__tstate);
39031 if (PyErr_Occurred()) SWIG_fail;
39032 }
39033 {
39034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39035 }
39036 return resultobj;
39037 fail:
39038 return NULL;
39039 }
39040
39041
39042 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39043 PyObject *resultobj;
39044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39045 int arg2 ;
39046 PyObject * obj0 = 0 ;
39047 PyObject * obj1 = 0 ;
39048 char *kwnames[] = {
39049 (char *) "self",(char *) "proportion", NULL
39050 };
39051
39052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39054 if (SWIG_arg_fail(1)) SWIG_fail;
39055 {
39056 arg2 = (int)(SWIG_As_int(obj1));
39057 if (SWIG_arg_fail(2)) SWIG_fail;
39058 }
39059 {
39060 PyThreadState* __tstate = wxPyBeginAllowThreads();
39061 (arg1)->SetProportion(arg2);
39062
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 Py_INCREF(Py_None); resultobj = Py_None;
39067 return resultobj;
39068 fail:
39069 return NULL;
39070 }
39071
39072
39073 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39074 PyObject *resultobj;
39075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39076 int result;
39077 PyObject * obj0 = 0 ;
39078 char *kwnames[] = {
39079 (char *) "self", NULL
39080 };
39081
39082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39084 if (SWIG_arg_fail(1)) SWIG_fail;
39085 {
39086 PyThreadState* __tstate = wxPyBeginAllowThreads();
39087 result = (int)(arg1)->GetProportion();
39088
39089 wxPyEndAllowThreads(__tstate);
39090 if (PyErr_Occurred()) SWIG_fail;
39091 }
39092 {
39093 resultobj = SWIG_From_int((int)(result));
39094 }
39095 return resultobj;
39096 fail:
39097 return NULL;
39098 }
39099
39100
39101 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39102 PyObject *resultobj;
39103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39104 int arg2 ;
39105 PyObject * obj0 = 0 ;
39106 PyObject * obj1 = 0 ;
39107 char *kwnames[] = {
39108 (char *) "self",(char *) "flag", NULL
39109 };
39110
39111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39113 if (SWIG_arg_fail(1)) SWIG_fail;
39114 {
39115 arg2 = (int)(SWIG_As_int(obj1));
39116 if (SWIG_arg_fail(2)) SWIG_fail;
39117 }
39118 {
39119 PyThreadState* __tstate = wxPyBeginAllowThreads();
39120 (arg1)->SetFlag(arg2);
39121
39122 wxPyEndAllowThreads(__tstate);
39123 if (PyErr_Occurred()) SWIG_fail;
39124 }
39125 Py_INCREF(Py_None); resultobj = Py_None;
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39133 PyObject *resultobj;
39134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39135 int result;
39136 PyObject * obj0 = 0 ;
39137 char *kwnames[] = {
39138 (char *) "self", NULL
39139 };
39140
39141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39143 if (SWIG_arg_fail(1)) SWIG_fail;
39144 {
39145 PyThreadState* __tstate = wxPyBeginAllowThreads();
39146 result = (int)(arg1)->GetFlag();
39147
39148 wxPyEndAllowThreads(__tstate);
39149 if (PyErr_Occurred()) SWIG_fail;
39150 }
39151 {
39152 resultobj = SWIG_From_int((int)(result));
39153 }
39154 return resultobj;
39155 fail:
39156 return NULL;
39157 }
39158
39159
39160 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39161 PyObject *resultobj;
39162 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39163 int arg2 ;
39164 PyObject * obj0 = 0 ;
39165 PyObject * obj1 = 0 ;
39166 char *kwnames[] = {
39167 (char *) "self",(char *) "border", NULL
39168 };
39169
39170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39172 if (SWIG_arg_fail(1)) SWIG_fail;
39173 {
39174 arg2 = (int)(SWIG_As_int(obj1));
39175 if (SWIG_arg_fail(2)) SWIG_fail;
39176 }
39177 {
39178 PyThreadState* __tstate = wxPyBeginAllowThreads();
39179 (arg1)->SetBorder(arg2);
39180
39181 wxPyEndAllowThreads(__tstate);
39182 if (PyErr_Occurred()) SWIG_fail;
39183 }
39184 Py_INCREF(Py_None); resultobj = Py_None;
39185 return resultobj;
39186 fail:
39187 return NULL;
39188 }
39189
39190
39191 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39192 PyObject *resultobj;
39193 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39194 int result;
39195 PyObject * obj0 = 0 ;
39196 char *kwnames[] = {
39197 (char *) "self", NULL
39198 };
39199
39200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39202 if (SWIG_arg_fail(1)) SWIG_fail;
39203 {
39204 PyThreadState* __tstate = wxPyBeginAllowThreads();
39205 result = (int)(arg1)->GetBorder();
39206
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 {
39211 resultobj = SWIG_From_int((int)(result));
39212 }
39213 return resultobj;
39214 fail:
39215 return NULL;
39216 }
39217
39218
39219 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj;
39221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39222 wxWindow *result;
39223 PyObject * obj0 = 0 ;
39224 char *kwnames[] = {
39225 (char *) "self", NULL
39226 };
39227
39228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39230 if (SWIG_arg_fail(1)) SWIG_fail;
39231 {
39232 PyThreadState* __tstate = wxPyBeginAllowThreads();
39233 result = (wxWindow *)(arg1)->GetWindow();
39234
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, 0);
39240 }
39241 return resultobj;
39242 fail:
39243 return NULL;
39244 }
39245
39246
39247 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39248 PyObject *resultobj;
39249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39250 wxWindow *arg2 = (wxWindow *) 0 ;
39251 PyObject * obj0 = 0 ;
39252 PyObject * obj1 = 0 ;
39253 char *kwnames[] = {
39254 (char *) "self",(char *) "window", NULL
39255 };
39256
39257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39259 if (SWIG_arg_fail(1)) SWIG_fail;
39260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39261 if (SWIG_arg_fail(2)) SWIG_fail;
39262 {
39263 PyThreadState* __tstate = wxPyBeginAllowThreads();
39264 (arg1)->SetWindow(arg2);
39265
39266 wxPyEndAllowThreads(__tstate);
39267 if (PyErr_Occurred()) SWIG_fail;
39268 }
39269 Py_INCREF(Py_None); resultobj = Py_None;
39270 return resultobj;
39271 fail:
39272 return NULL;
39273 }
39274
39275
39276 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39277 PyObject *resultobj;
39278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39279 wxSizer *result;
39280 PyObject * obj0 = 0 ;
39281 char *kwnames[] = {
39282 (char *) "self", NULL
39283 };
39284
39285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39287 if (SWIG_arg_fail(1)) SWIG_fail;
39288 {
39289 PyThreadState* __tstate = wxPyBeginAllowThreads();
39290 result = (wxSizer *)(arg1)->GetSizer();
39291
39292 wxPyEndAllowThreads(__tstate);
39293 if (PyErr_Occurred()) SWIG_fail;
39294 }
39295 {
39296 resultobj = wxPyMake_wxSizer(result, 0);
39297 }
39298 return resultobj;
39299 fail:
39300 return NULL;
39301 }
39302
39303
39304 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39305 PyObject *resultobj;
39306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39307 wxSizer *arg2 = (wxSizer *) 0 ;
39308 PyObject * obj0 = 0 ;
39309 PyObject * obj1 = 0 ;
39310 char *kwnames[] = {
39311 (char *) "self",(char *) "sizer", NULL
39312 };
39313
39314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39316 if (SWIG_arg_fail(1)) SWIG_fail;
39317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39318 if (SWIG_arg_fail(2)) SWIG_fail;
39319 {
39320 PyThreadState* __tstate = wxPyBeginAllowThreads();
39321 (arg1)->SetSizer(arg2);
39322
39323 wxPyEndAllowThreads(__tstate);
39324 if (PyErr_Occurred()) SWIG_fail;
39325 }
39326 Py_INCREF(Py_None); resultobj = Py_None;
39327 return resultobj;
39328 fail:
39329 return NULL;
39330 }
39331
39332
39333 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39334 PyObject *resultobj;
39335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39336 wxSize *result;
39337 PyObject * obj0 = 0 ;
39338 char *kwnames[] = {
39339 (char *) "self", NULL
39340 };
39341
39342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39344 if (SWIG_arg_fail(1)) SWIG_fail;
39345 {
39346 PyThreadState* __tstate = wxPyBeginAllowThreads();
39347 {
39348 wxSize const &_result_ref = (arg1)->GetSpacer();
39349 result = (wxSize *) &_result_ref;
39350 }
39351
39352 wxPyEndAllowThreads(__tstate);
39353 if (PyErr_Occurred()) SWIG_fail;
39354 }
39355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39356 return resultobj;
39357 fail:
39358 return NULL;
39359 }
39360
39361
39362 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39363 PyObject *resultobj;
39364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39365 wxSize *arg2 = 0 ;
39366 wxSize temp2 ;
39367 PyObject * obj0 = 0 ;
39368 PyObject * obj1 = 0 ;
39369 char *kwnames[] = {
39370 (char *) "self",(char *) "size", NULL
39371 };
39372
39373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39375 if (SWIG_arg_fail(1)) SWIG_fail;
39376 {
39377 arg2 = &temp2;
39378 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39379 }
39380 {
39381 PyThreadState* __tstate = wxPyBeginAllowThreads();
39382 (arg1)->SetSpacer((wxSize const &)*arg2);
39383
39384 wxPyEndAllowThreads(__tstate);
39385 if (PyErr_Occurred()) SWIG_fail;
39386 }
39387 Py_INCREF(Py_None); resultobj = Py_None;
39388 return resultobj;
39389 fail:
39390 return NULL;
39391 }
39392
39393
39394 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39395 PyObject *resultobj;
39396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39397 bool arg2 ;
39398 PyObject * obj0 = 0 ;
39399 PyObject * obj1 = 0 ;
39400 char *kwnames[] = {
39401 (char *) "self",(char *) "show", NULL
39402 };
39403
39404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39406 if (SWIG_arg_fail(1)) SWIG_fail;
39407 {
39408 arg2 = (bool)(SWIG_As_bool(obj1));
39409 if (SWIG_arg_fail(2)) SWIG_fail;
39410 }
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 (arg1)->Show(arg2);
39414
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 Py_INCREF(Py_None); resultobj = Py_None;
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj;
39427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39428 bool result;
39429 PyObject * obj0 = 0 ;
39430 char *kwnames[] = {
39431 (char *) "self", NULL
39432 };
39433
39434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39436 if (SWIG_arg_fail(1)) SWIG_fail;
39437 {
39438 PyThreadState* __tstate = wxPyBeginAllowThreads();
39439 result = (bool)(arg1)->IsShown();
39440
39441 wxPyEndAllowThreads(__tstate);
39442 if (PyErr_Occurred()) SWIG_fail;
39443 }
39444 {
39445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39446 }
39447 return resultobj;
39448 fail:
39449 return NULL;
39450 }
39451
39452
39453 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39454 PyObject *resultobj;
39455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39456 wxPoint result;
39457 PyObject * obj0 = 0 ;
39458 char *kwnames[] = {
39459 (char *) "self", NULL
39460 };
39461
39462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39464 if (SWIG_arg_fail(1)) SWIG_fail;
39465 {
39466 PyThreadState* __tstate = wxPyBeginAllowThreads();
39467 result = (arg1)->GetPosition();
39468
39469 wxPyEndAllowThreads(__tstate);
39470 if (PyErr_Occurred()) SWIG_fail;
39471 }
39472 {
39473 wxPoint * resultptr;
39474 resultptr = new wxPoint((wxPoint &)(result));
39475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39476 }
39477 return resultobj;
39478 fail:
39479 return NULL;
39480 }
39481
39482
39483 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39484 PyObject *resultobj;
39485 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39486 PyObject *result;
39487 PyObject * obj0 = 0 ;
39488 char *kwnames[] = {
39489 (char *) "self", NULL
39490 };
39491
39492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39494 if (SWIG_arg_fail(1)) SWIG_fail;
39495 {
39496 PyThreadState* __tstate = wxPyBeginAllowThreads();
39497 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39498
39499 wxPyEndAllowThreads(__tstate);
39500 if (PyErr_Occurred()) SWIG_fail;
39501 }
39502 resultobj = result;
39503 return resultobj;
39504 fail:
39505 return NULL;
39506 }
39507
39508
39509 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39510 PyObject *obj;
39511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39512 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39513 Py_INCREF(obj);
39514 return Py_BuildValue((char *)"");
39515 }
39516 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39517 PyObject *resultobj;
39518 wxSizer *arg1 = (wxSizer *) 0 ;
39519 PyObject *arg2 = (PyObject *) 0 ;
39520 PyObject * obj0 = 0 ;
39521 PyObject * obj1 = 0 ;
39522 char *kwnames[] = {
39523 (char *) "self",(char *) "_self", NULL
39524 };
39525
39526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39528 if (SWIG_arg_fail(1)) SWIG_fail;
39529 arg2 = obj1;
39530 {
39531 PyThreadState* __tstate = wxPyBeginAllowThreads();
39532 wxSizer__setOORInfo(arg1,arg2);
39533
39534 wxPyEndAllowThreads(__tstate);
39535 if (PyErr_Occurred()) SWIG_fail;
39536 }
39537 Py_INCREF(Py_None); resultobj = Py_None;
39538 return resultobj;
39539 fail:
39540 return NULL;
39541 }
39542
39543
39544 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39545 PyObject *resultobj;
39546 wxSizer *arg1 = (wxSizer *) 0 ;
39547 PyObject *arg2 = (PyObject *) 0 ;
39548 int arg3 = (int) 0 ;
39549 int arg4 = (int) 0 ;
39550 int arg5 = (int) 0 ;
39551 PyObject *arg6 = (PyObject *) NULL ;
39552 wxSizerItem *result;
39553 PyObject * obj0 = 0 ;
39554 PyObject * obj1 = 0 ;
39555 PyObject * obj2 = 0 ;
39556 PyObject * obj3 = 0 ;
39557 PyObject * obj4 = 0 ;
39558 PyObject * obj5 = 0 ;
39559 char *kwnames[] = {
39560 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39561 };
39562
39563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 arg2 = obj1;
39567 if (obj2) {
39568 {
39569 arg3 = (int)(SWIG_As_int(obj2));
39570 if (SWIG_arg_fail(3)) SWIG_fail;
39571 }
39572 }
39573 if (obj3) {
39574 {
39575 arg4 = (int)(SWIG_As_int(obj3));
39576 if (SWIG_arg_fail(4)) SWIG_fail;
39577 }
39578 }
39579 if (obj4) {
39580 {
39581 arg5 = (int)(SWIG_As_int(obj4));
39582 if (SWIG_arg_fail(5)) SWIG_fail;
39583 }
39584 }
39585 if (obj5) {
39586 arg6 = obj5;
39587 }
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39591
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39603 PyObject *resultobj;
39604 wxSizer *arg1 = (wxSizer *) 0 ;
39605 int arg2 ;
39606 PyObject *arg3 = (PyObject *) 0 ;
39607 int arg4 = (int) 0 ;
39608 int arg5 = (int) 0 ;
39609 int arg6 = (int) 0 ;
39610 PyObject *arg7 = (PyObject *) NULL ;
39611 wxSizerItem *result;
39612 PyObject * obj0 = 0 ;
39613 PyObject * obj1 = 0 ;
39614 PyObject * obj2 = 0 ;
39615 PyObject * obj3 = 0 ;
39616 PyObject * obj4 = 0 ;
39617 PyObject * obj5 = 0 ;
39618 PyObject * obj6 = 0 ;
39619 char *kwnames[] = {
39620 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39621 };
39622
39623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39625 if (SWIG_arg_fail(1)) SWIG_fail;
39626 {
39627 arg2 = (int)(SWIG_As_int(obj1));
39628 if (SWIG_arg_fail(2)) SWIG_fail;
39629 }
39630 arg3 = obj2;
39631 if (obj3) {
39632 {
39633 arg4 = (int)(SWIG_As_int(obj3));
39634 if (SWIG_arg_fail(4)) SWIG_fail;
39635 }
39636 }
39637 if (obj4) {
39638 {
39639 arg5 = (int)(SWIG_As_int(obj4));
39640 if (SWIG_arg_fail(5)) SWIG_fail;
39641 }
39642 }
39643 if (obj5) {
39644 {
39645 arg6 = (int)(SWIG_As_int(obj5));
39646 if (SWIG_arg_fail(6)) SWIG_fail;
39647 }
39648 }
39649 if (obj6) {
39650 arg7 = obj6;
39651 }
39652 {
39653 PyThreadState* __tstate = wxPyBeginAllowThreads();
39654 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39655
39656 wxPyEndAllowThreads(__tstate);
39657 if (PyErr_Occurred()) SWIG_fail;
39658 }
39659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39660 return resultobj;
39661 fail:
39662 return NULL;
39663 }
39664
39665
39666 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39667 PyObject *resultobj;
39668 wxSizer *arg1 = (wxSizer *) 0 ;
39669 PyObject *arg2 = (PyObject *) 0 ;
39670 int arg3 = (int) 0 ;
39671 int arg4 = (int) 0 ;
39672 int arg5 = (int) 0 ;
39673 PyObject *arg6 = (PyObject *) NULL ;
39674 wxSizerItem *result;
39675 PyObject * obj0 = 0 ;
39676 PyObject * obj1 = 0 ;
39677 PyObject * obj2 = 0 ;
39678 PyObject * obj3 = 0 ;
39679 PyObject * obj4 = 0 ;
39680 PyObject * obj5 = 0 ;
39681 char *kwnames[] = {
39682 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39683 };
39684
39685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39687 if (SWIG_arg_fail(1)) SWIG_fail;
39688 arg2 = obj1;
39689 if (obj2) {
39690 {
39691 arg3 = (int)(SWIG_As_int(obj2));
39692 if (SWIG_arg_fail(3)) SWIG_fail;
39693 }
39694 }
39695 if (obj3) {
39696 {
39697 arg4 = (int)(SWIG_As_int(obj3));
39698 if (SWIG_arg_fail(4)) SWIG_fail;
39699 }
39700 }
39701 if (obj4) {
39702 {
39703 arg5 = (int)(SWIG_As_int(obj4));
39704 if (SWIG_arg_fail(5)) SWIG_fail;
39705 }
39706 }
39707 if (obj5) {
39708 arg6 = obj5;
39709 }
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39713
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39718 return resultobj;
39719 fail:
39720 return NULL;
39721 }
39722
39723
39724 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39725 PyObject *resultobj;
39726 wxSizer *arg1 = (wxSizer *) 0 ;
39727 PyObject *arg2 = (PyObject *) 0 ;
39728 bool result;
39729 PyObject * obj0 = 0 ;
39730 PyObject * obj1 = 0 ;
39731 char *kwnames[] = {
39732 (char *) "self",(char *) "item", NULL
39733 };
39734
39735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 arg2 = obj1;
39739 {
39740 PyThreadState* __tstate = wxPyBeginAllowThreads();
39741 result = (bool)wxSizer_Remove(arg1,arg2);
39742
39743 wxPyEndAllowThreads(__tstate);
39744 if (PyErr_Occurred()) SWIG_fail;
39745 }
39746 {
39747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39748 }
39749 return resultobj;
39750 fail:
39751 return NULL;
39752 }
39753
39754
39755 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39756 PyObject *resultobj;
39757 wxSizer *arg1 = (wxSizer *) 0 ;
39758 PyObject *arg2 = (PyObject *) 0 ;
39759 bool result;
39760 PyObject * obj0 = 0 ;
39761 PyObject * obj1 = 0 ;
39762 char *kwnames[] = {
39763 (char *) "self",(char *) "item", NULL
39764 };
39765
39766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39768 if (SWIG_arg_fail(1)) SWIG_fail;
39769 arg2 = obj1;
39770 {
39771 PyThreadState* __tstate = wxPyBeginAllowThreads();
39772 result = (bool)wxSizer_Detach(arg1,arg2);
39773
39774 wxPyEndAllowThreads(__tstate);
39775 if (PyErr_Occurred()) SWIG_fail;
39776 }
39777 {
39778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39779 }
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj;
39788 wxSizer *arg1 = (wxSizer *) 0 ;
39789 PyObject *arg2 = (PyObject *) 0 ;
39790 wxSizerItem *result;
39791 PyObject * obj0 = 0 ;
39792 PyObject * obj1 = 0 ;
39793 char *kwnames[] = {
39794 (char *) "self",(char *) "item", NULL
39795 };
39796
39797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39799 if (SWIG_arg_fail(1)) SWIG_fail;
39800 arg2 = obj1;
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39804
39805 wxPyEndAllowThreads(__tstate);
39806 if (PyErr_Occurred()) SWIG_fail;
39807 }
39808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39809 return resultobj;
39810 fail:
39811 return NULL;
39812 }
39813
39814
39815 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj;
39817 wxSizer *arg1 = (wxSizer *) 0 ;
39818 PyObject *arg2 = (PyObject *) 0 ;
39819 wxSize *arg3 = 0 ;
39820 wxSize temp3 ;
39821 PyObject * obj0 = 0 ;
39822 PyObject * obj1 = 0 ;
39823 PyObject * obj2 = 0 ;
39824 char *kwnames[] = {
39825 (char *) "self",(char *) "item",(char *) "size", NULL
39826 };
39827
39828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39830 if (SWIG_arg_fail(1)) SWIG_fail;
39831 arg2 = obj1;
39832 {
39833 arg3 = &temp3;
39834 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39835 }
39836 {
39837 PyThreadState* __tstate = wxPyBeginAllowThreads();
39838 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39839
39840 wxPyEndAllowThreads(__tstate);
39841 if (PyErr_Occurred()) SWIG_fail;
39842 }
39843 Py_INCREF(Py_None); resultobj = Py_None;
39844 return resultobj;
39845 fail:
39846 return NULL;
39847 }
39848
39849
39850 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39851 PyObject *resultobj;
39852 wxSizer *arg1 = (wxSizer *) 0 ;
39853 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39854 wxSizerItem *result;
39855 PyObject * obj0 = 0 ;
39856 PyObject * obj1 = 0 ;
39857 char *kwnames[] = {
39858 (char *) "self",(char *) "item", NULL
39859 };
39860
39861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39863 if (SWIG_arg_fail(1)) SWIG_fail;
39864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39865 if (SWIG_arg_fail(2)) SWIG_fail;
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (wxSizerItem *)(arg1)->Add(arg2);
39869
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39874 return resultobj;
39875 fail:
39876 return NULL;
39877 }
39878
39879
39880 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39881 PyObject *resultobj;
39882 wxSizer *arg1 = (wxSizer *) 0 ;
39883 size_t arg2 ;
39884 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39885 wxSizerItem *result;
39886 PyObject * obj0 = 0 ;
39887 PyObject * obj1 = 0 ;
39888 PyObject * obj2 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self",(char *) "index",(char *) "item", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 {
39897 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39898 if (SWIG_arg_fail(2)) SWIG_fail;
39899 }
39900 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39901 if (SWIG_arg_fail(3)) SWIG_fail;
39902 {
39903 PyThreadState* __tstate = wxPyBeginAllowThreads();
39904 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39905
39906 wxPyEndAllowThreads(__tstate);
39907 if (PyErr_Occurred()) SWIG_fail;
39908 }
39909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39910 return resultobj;
39911 fail:
39912 return NULL;
39913 }
39914
39915
39916 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39917 PyObject *resultobj;
39918 wxSizer *arg1 = (wxSizer *) 0 ;
39919 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39920 wxSizerItem *result;
39921 PyObject * obj0 = 0 ;
39922 PyObject * obj1 = 0 ;
39923 char *kwnames[] = {
39924 (char *) "self",(char *) "item", NULL
39925 };
39926
39927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39929 if (SWIG_arg_fail(1)) SWIG_fail;
39930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39931 if (SWIG_arg_fail(2)) SWIG_fail;
39932 {
39933 PyThreadState* __tstate = wxPyBeginAllowThreads();
39934 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39935
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj;
39948 wxSizer *arg1 = (wxSizer *) 0 ;
39949 int arg2 ;
39950 int arg3 ;
39951 int arg4 ;
39952 int arg5 ;
39953 PyObject * obj0 = 0 ;
39954 PyObject * obj1 = 0 ;
39955 PyObject * obj2 = 0 ;
39956 PyObject * obj3 = 0 ;
39957 PyObject * obj4 = 0 ;
39958 char *kwnames[] = {
39959 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39960 };
39961
39962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39964 if (SWIG_arg_fail(1)) SWIG_fail;
39965 {
39966 arg2 = (int)(SWIG_As_int(obj1));
39967 if (SWIG_arg_fail(2)) SWIG_fail;
39968 }
39969 {
39970 arg3 = (int)(SWIG_As_int(obj2));
39971 if (SWIG_arg_fail(3)) SWIG_fail;
39972 }
39973 {
39974 arg4 = (int)(SWIG_As_int(obj3));
39975 if (SWIG_arg_fail(4)) SWIG_fail;
39976 }
39977 {
39978 arg5 = (int)(SWIG_As_int(obj4));
39979 if (SWIG_arg_fail(5)) SWIG_fail;
39980 }
39981 {
39982 PyThreadState* __tstate = wxPyBeginAllowThreads();
39983 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39984
39985 wxPyEndAllowThreads(__tstate);
39986 if (PyErr_Occurred()) SWIG_fail;
39987 }
39988 Py_INCREF(Py_None); resultobj = Py_None;
39989 return resultobj;
39990 fail:
39991 return NULL;
39992 }
39993
39994
39995 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39996 PyObject *resultobj;
39997 wxSizer *arg1 = (wxSizer *) 0 ;
39998 wxSize *arg2 = 0 ;
39999 wxSize temp2 ;
40000 PyObject * obj0 = 0 ;
40001 PyObject * obj1 = 0 ;
40002 char *kwnames[] = {
40003 (char *) "self",(char *) "size", NULL
40004 };
40005
40006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40008 if (SWIG_arg_fail(1)) SWIG_fail;
40009 {
40010 arg2 = &temp2;
40011 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40012 }
40013 {
40014 PyThreadState* __tstate = wxPyBeginAllowThreads();
40015 (arg1)->SetMinSize((wxSize const &)*arg2);
40016
40017 wxPyEndAllowThreads(__tstate);
40018 if (PyErr_Occurred()) SWIG_fail;
40019 }
40020 Py_INCREF(Py_None); resultobj = Py_None;
40021 return resultobj;
40022 fail:
40023 return NULL;
40024 }
40025
40026
40027 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj;
40029 wxSizer *arg1 = (wxSizer *) 0 ;
40030 wxSize result;
40031 PyObject * obj0 = 0 ;
40032 char *kwnames[] = {
40033 (char *) "self", NULL
40034 };
40035
40036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40038 if (SWIG_arg_fail(1)) SWIG_fail;
40039 {
40040 PyThreadState* __tstate = wxPyBeginAllowThreads();
40041 result = (arg1)->GetSize();
40042
40043 wxPyEndAllowThreads(__tstate);
40044 if (PyErr_Occurred()) SWIG_fail;
40045 }
40046 {
40047 wxSize * resultptr;
40048 resultptr = new wxSize((wxSize &)(result));
40049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40050 }
40051 return resultobj;
40052 fail:
40053 return NULL;
40054 }
40055
40056
40057 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40058 PyObject *resultobj;
40059 wxSizer *arg1 = (wxSizer *) 0 ;
40060 wxPoint result;
40061 PyObject * obj0 = 0 ;
40062 char *kwnames[] = {
40063 (char *) "self", NULL
40064 };
40065
40066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40068 if (SWIG_arg_fail(1)) SWIG_fail;
40069 {
40070 PyThreadState* __tstate = wxPyBeginAllowThreads();
40071 result = (arg1)->GetPosition();
40072
40073 wxPyEndAllowThreads(__tstate);
40074 if (PyErr_Occurred()) SWIG_fail;
40075 }
40076 {
40077 wxPoint * resultptr;
40078 resultptr = new wxPoint((wxPoint &)(result));
40079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj;
40089 wxSizer *arg1 = (wxSizer *) 0 ;
40090 wxSize result;
40091 PyObject * obj0 = 0 ;
40092 char *kwnames[] = {
40093 (char *) "self", NULL
40094 };
40095
40096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40098 if (SWIG_arg_fail(1)) SWIG_fail;
40099 {
40100 PyThreadState* __tstate = wxPyBeginAllowThreads();
40101 result = (arg1)->GetMinSize();
40102
40103 wxPyEndAllowThreads(__tstate);
40104 if (PyErr_Occurred()) SWIG_fail;
40105 }
40106 {
40107 wxSize * resultptr;
40108 resultptr = new wxSize((wxSize &)(result));
40109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40110 }
40111 return resultobj;
40112 fail:
40113 return NULL;
40114 }
40115
40116
40117 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40118 PyObject *resultobj;
40119 wxSizer *arg1 = (wxSizer *) 0 ;
40120 PyObject * obj0 = 0 ;
40121 char *kwnames[] = {
40122 (char *) "self", NULL
40123 };
40124
40125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40127 if (SWIG_arg_fail(1)) SWIG_fail;
40128 {
40129 PyThreadState* __tstate = wxPyBeginAllowThreads();
40130 (arg1)->RecalcSizes();
40131
40132 wxPyEndAllowThreads(__tstate);
40133 if (PyErr_Occurred()) SWIG_fail;
40134 }
40135 Py_INCREF(Py_None); resultobj = Py_None;
40136 return resultobj;
40137 fail:
40138 return NULL;
40139 }
40140
40141
40142 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40143 PyObject *resultobj;
40144 wxSizer *arg1 = (wxSizer *) 0 ;
40145 wxSize result;
40146 PyObject * obj0 = 0 ;
40147 char *kwnames[] = {
40148 (char *) "self", NULL
40149 };
40150
40151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40153 if (SWIG_arg_fail(1)) SWIG_fail;
40154 {
40155 PyThreadState* __tstate = wxPyBeginAllowThreads();
40156 result = (arg1)->CalcMin();
40157
40158 wxPyEndAllowThreads(__tstate);
40159 if (PyErr_Occurred()) SWIG_fail;
40160 }
40161 {
40162 wxSize * resultptr;
40163 resultptr = new wxSize((wxSize &)(result));
40164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40165 }
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj;
40174 wxSizer *arg1 = (wxSizer *) 0 ;
40175 PyObject * obj0 = 0 ;
40176 char *kwnames[] = {
40177 (char *) "self", NULL
40178 };
40179
40180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40182 if (SWIG_arg_fail(1)) SWIG_fail;
40183 {
40184 PyThreadState* __tstate = wxPyBeginAllowThreads();
40185 (arg1)->Layout();
40186
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 Py_INCREF(Py_None); resultobj = Py_None;
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj;
40199 wxSizer *arg1 = (wxSizer *) 0 ;
40200 wxWindow *arg2 = (wxWindow *) 0 ;
40201 wxSize result;
40202 PyObject * obj0 = 0 ;
40203 PyObject * obj1 = 0 ;
40204 char *kwnames[] = {
40205 (char *) "self",(char *) "window", NULL
40206 };
40207
40208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40210 if (SWIG_arg_fail(1)) SWIG_fail;
40211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40212 if (SWIG_arg_fail(2)) SWIG_fail;
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = (arg1)->Fit(arg2);
40216
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 {
40221 wxSize * resultptr;
40222 resultptr = new wxSize((wxSize &)(result));
40223 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40224 }
40225 return resultobj;
40226 fail:
40227 return NULL;
40228 }
40229
40230
40231 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40232 PyObject *resultobj;
40233 wxSizer *arg1 = (wxSizer *) 0 ;
40234 wxWindow *arg2 = (wxWindow *) 0 ;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 char *kwnames[] = {
40238 (char *) "self",(char *) "window", NULL
40239 };
40240
40241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40243 if (SWIG_arg_fail(1)) SWIG_fail;
40244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40245 if (SWIG_arg_fail(2)) SWIG_fail;
40246 {
40247 PyThreadState* __tstate = wxPyBeginAllowThreads();
40248 (arg1)->FitInside(arg2);
40249
40250 wxPyEndAllowThreads(__tstate);
40251 if (PyErr_Occurred()) SWIG_fail;
40252 }
40253 Py_INCREF(Py_None); resultobj = Py_None;
40254 return resultobj;
40255 fail:
40256 return NULL;
40257 }
40258
40259
40260 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40261 PyObject *resultobj;
40262 wxSizer *arg1 = (wxSizer *) 0 ;
40263 wxWindow *arg2 = (wxWindow *) 0 ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char *kwnames[] = {
40267 (char *) "self",(char *) "window", NULL
40268 };
40269
40270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40272 if (SWIG_arg_fail(1)) SWIG_fail;
40273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40274 if (SWIG_arg_fail(2)) SWIG_fail;
40275 {
40276 PyThreadState* __tstate = wxPyBeginAllowThreads();
40277 (arg1)->SetSizeHints(arg2);
40278
40279 wxPyEndAllowThreads(__tstate);
40280 if (PyErr_Occurred()) SWIG_fail;
40281 }
40282 Py_INCREF(Py_None); resultobj = Py_None;
40283 return resultobj;
40284 fail:
40285 return NULL;
40286 }
40287
40288
40289 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40290 PyObject *resultobj;
40291 wxSizer *arg1 = (wxSizer *) 0 ;
40292 wxWindow *arg2 = (wxWindow *) 0 ;
40293 PyObject * obj0 = 0 ;
40294 PyObject * obj1 = 0 ;
40295 char *kwnames[] = {
40296 (char *) "self",(char *) "window", NULL
40297 };
40298
40299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40301 if (SWIG_arg_fail(1)) SWIG_fail;
40302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40303 if (SWIG_arg_fail(2)) SWIG_fail;
40304 {
40305 PyThreadState* __tstate = wxPyBeginAllowThreads();
40306 (arg1)->SetVirtualSizeHints(arg2);
40307
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 Py_INCREF(Py_None); resultobj = Py_None;
40312 return resultobj;
40313 fail:
40314 return NULL;
40315 }
40316
40317
40318 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj;
40320 wxSizer *arg1 = (wxSizer *) 0 ;
40321 bool arg2 = (bool) false ;
40322 PyObject * obj0 = 0 ;
40323 PyObject * obj1 = 0 ;
40324 char *kwnames[] = {
40325 (char *) "self",(char *) "deleteWindows", NULL
40326 };
40327
40328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40330 if (SWIG_arg_fail(1)) SWIG_fail;
40331 if (obj1) {
40332 {
40333 arg2 = (bool)(SWIG_As_bool(obj1));
40334 if (SWIG_arg_fail(2)) SWIG_fail;
40335 }
40336 }
40337 {
40338 PyThreadState* __tstate = wxPyBeginAllowThreads();
40339 (arg1)->Clear(arg2);
40340
40341 wxPyEndAllowThreads(__tstate);
40342 if (PyErr_Occurred()) SWIG_fail;
40343 }
40344 Py_INCREF(Py_None); resultobj = Py_None;
40345 return resultobj;
40346 fail:
40347 return NULL;
40348 }
40349
40350
40351 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40352 PyObject *resultobj;
40353 wxSizer *arg1 = (wxSizer *) 0 ;
40354 PyObject * obj0 = 0 ;
40355 char *kwnames[] = {
40356 (char *) "self", NULL
40357 };
40358
40359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40361 if (SWIG_arg_fail(1)) SWIG_fail;
40362 {
40363 PyThreadState* __tstate = wxPyBeginAllowThreads();
40364 (arg1)->DeleteWindows();
40365
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 Py_INCREF(Py_None); resultobj = Py_None;
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj;
40378 wxSizer *arg1 = (wxSizer *) 0 ;
40379 PyObject *result;
40380 PyObject * obj0 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 result = (PyObject *)wxSizer_GetChildren(arg1);
40391
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = result;
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40403 PyObject *resultobj;
40404 wxSizer *arg1 = (wxSizer *) 0 ;
40405 PyObject *arg2 = (PyObject *) 0 ;
40406 bool arg3 = (bool) true ;
40407 bool arg4 = (bool) false ;
40408 bool result;
40409 PyObject * obj0 = 0 ;
40410 PyObject * obj1 = 0 ;
40411 PyObject * obj2 = 0 ;
40412 PyObject * obj3 = 0 ;
40413 char *kwnames[] = {
40414 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40415 };
40416
40417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40419 if (SWIG_arg_fail(1)) SWIG_fail;
40420 arg2 = obj1;
40421 if (obj2) {
40422 {
40423 arg3 = (bool)(SWIG_As_bool(obj2));
40424 if (SWIG_arg_fail(3)) SWIG_fail;
40425 }
40426 }
40427 if (obj3) {
40428 {
40429 arg4 = (bool)(SWIG_As_bool(obj3));
40430 if (SWIG_arg_fail(4)) SWIG_fail;
40431 }
40432 }
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40436
40437 wxPyEndAllowThreads(__tstate);
40438 if (PyErr_Occurred()) SWIG_fail;
40439 }
40440 {
40441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40442 }
40443 return resultobj;
40444 fail:
40445 return NULL;
40446 }
40447
40448
40449 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40450 PyObject *resultobj;
40451 wxSizer *arg1 = (wxSizer *) 0 ;
40452 PyObject *arg2 = (PyObject *) 0 ;
40453 bool result;
40454 PyObject * obj0 = 0 ;
40455 PyObject * obj1 = 0 ;
40456 char *kwnames[] = {
40457 (char *) "self",(char *) "item", NULL
40458 };
40459
40460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40462 if (SWIG_arg_fail(1)) SWIG_fail;
40463 arg2 = obj1;
40464 {
40465 PyThreadState* __tstate = wxPyBeginAllowThreads();
40466 result = (bool)wxSizer_IsShown(arg1,arg2);
40467
40468 wxPyEndAllowThreads(__tstate);
40469 if (PyErr_Occurred()) SWIG_fail;
40470 }
40471 {
40472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40473 }
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj;
40482 wxSizer *arg1 = (wxSizer *) 0 ;
40483 bool arg2 ;
40484 PyObject * obj0 = 0 ;
40485 PyObject * obj1 = 0 ;
40486 char *kwnames[] = {
40487 (char *) "self",(char *) "show", NULL
40488 };
40489
40490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40492 if (SWIG_arg_fail(1)) SWIG_fail;
40493 {
40494 arg2 = (bool)(SWIG_As_bool(obj1));
40495 if (SWIG_arg_fail(2)) SWIG_fail;
40496 }
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 (arg1)->ShowItems(arg2);
40500
40501 wxPyEndAllowThreads(__tstate);
40502 if (PyErr_Occurred()) SWIG_fail;
40503 }
40504 Py_INCREF(Py_None); resultobj = Py_None;
40505 return resultobj;
40506 fail:
40507 return NULL;
40508 }
40509
40510
40511 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40512 PyObject *obj;
40513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40514 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40515 Py_INCREF(obj);
40516 return Py_BuildValue((char *)"");
40517 }
40518 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40519 PyObject *resultobj;
40520 wxPySizer *result;
40521 char *kwnames[] = {
40522 NULL
40523 };
40524
40525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40526 {
40527 PyThreadState* __tstate = wxPyBeginAllowThreads();
40528 result = (wxPySizer *)new wxPySizer();
40529
40530 wxPyEndAllowThreads(__tstate);
40531 if (PyErr_Occurred()) SWIG_fail;
40532 }
40533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40541 PyObject *resultobj;
40542 wxPySizer *arg1 = (wxPySizer *) 0 ;
40543 PyObject *arg2 = (PyObject *) 0 ;
40544 PyObject *arg3 = (PyObject *) 0 ;
40545 PyObject * obj0 = 0 ;
40546 PyObject * obj1 = 0 ;
40547 PyObject * obj2 = 0 ;
40548 char *kwnames[] = {
40549 (char *) "self",(char *) "self",(char *) "_class", NULL
40550 };
40551
40552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40554 if (SWIG_arg_fail(1)) SWIG_fail;
40555 arg2 = obj1;
40556 arg3 = obj2;
40557 {
40558 PyThreadState* __tstate = wxPyBeginAllowThreads();
40559 (arg1)->_setCallbackInfo(arg2,arg3);
40560
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 Py_INCREF(Py_None); resultobj = Py_None;
40565 return resultobj;
40566 fail:
40567 return NULL;
40568 }
40569
40570
40571 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40572 PyObject *obj;
40573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40574 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40575 Py_INCREF(obj);
40576 return Py_BuildValue((char *)"");
40577 }
40578 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj;
40580 int arg1 = (int) wxHORIZONTAL ;
40581 wxBoxSizer *result;
40582 PyObject * obj0 = 0 ;
40583 char *kwnames[] = {
40584 (char *) "orient", NULL
40585 };
40586
40587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40588 if (obj0) {
40589 {
40590 arg1 = (int)(SWIG_As_int(obj0));
40591 if (SWIG_arg_fail(1)) SWIG_fail;
40592 }
40593 }
40594 {
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40597
40598 wxPyEndAllowThreads(__tstate);
40599 if (PyErr_Occurred()) SWIG_fail;
40600 }
40601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40602 return resultobj;
40603 fail:
40604 return NULL;
40605 }
40606
40607
40608 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40609 PyObject *resultobj;
40610 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40611 int result;
40612 PyObject * obj0 = 0 ;
40613 char *kwnames[] = {
40614 (char *) "self", NULL
40615 };
40616
40617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40619 if (SWIG_arg_fail(1)) SWIG_fail;
40620 {
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 result = (int)(arg1)->GetOrientation();
40623
40624 wxPyEndAllowThreads(__tstate);
40625 if (PyErr_Occurred()) SWIG_fail;
40626 }
40627 {
40628 resultobj = SWIG_From_int((int)(result));
40629 }
40630 return resultobj;
40631 fail:
40632 return NULL;
40633 }
40634
40635
40636 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40637 PyObject *resultobj;
40638 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40639 int arg2 ;
40640 PyObject * obj0 = 0 ;
40641 PyObject * obj1 = 0 ;
40642 char *kwnames[] = {
40643 (char *) "self",(char *) "orient", NULL
40644 };
40645
40646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40648 if (SWIG_arg_fail(1)) SWIG_fail;
40649 {
40650 arg2 = (int)(SWIG_As_int(obj1));
40651 if (SWIG_arg_fail(2)) SWIG_fail;
40652 }
40653 {
40654 PyThreadState* __tstate = wxPyBeginAllowThreads();
40655 (arg1)->SetOrientation(arg2);
40656
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 Py_INCREF(Py_None); resultobj = Py_None;
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40668 PyObject *obj;
40669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40670 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40671 Py_INCREF(obj);
40672 return Py_BuildValue((char *)"");
40673 }
40674 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40675 PyObject *resultobj;
40676 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40677 int arg2 = (int) wxHORIZONTAL ;
40678 wxStaticBoxSizer *result;
40679 PyObject * obj0 = 0 ;
40680 PyObject * obj1 = 0 ;
40681 char *kwnames[] = {
40682 (char *) "box",(char *) "orient", NULL
40683 };
40684
40685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40687 if (SWIG_arg_fail(1)) SWIG_fail;
40688 if (obj1) {
40689 {
40690 arg2 = (int)(SWIG_As_int(obj1));
40691 if (SWIG_arg_fail(2)) SWIG_fail;
40692 }
40693 }
40694 {
40695 PyThreadState* __tstate = wxPyBeginAllowThreads();
40696 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40697
40698 wxPyEndAllowThreads(__tstate);
40699 if (PyErr_Occurred()) SWIG_fail;
40700 }
40701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40702 return resultobj;
40703 fail:
40704 return NULL;
40705 }
40706
40707
40708 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40709 PyObject *resultobj;
40710 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40711 wxStaticBox *result;
40712 PyObject * obj0 = 0 ;
40713 char *kwnames[] = {
40714 (char *) "self", NULL
40715 };
40716
40717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40719 if (SWIG_arg_fail(1)) SWIG_fail;
40720 {
40721 PyThreadState* __tstate = wxPyBeginAllowThreads();
40722 result = (wxStaticBox *)(arg1)->GetStaticBox();
40723
40724 wxPyEndAllowThreads(__tstate);
40725 if (PyErr_Occurred()) SWIG_fail;
40726 }
40727 {
40728 resultobj = wxPyMake_wxObject(result, 0);
40729 }
40730 return resultobj;
40731 fail:
40732 return NULL;
40733 }
40734
40735
40736 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40737 PyObject *obj;
40738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40739 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40740 Py_INCREF(obj);
40741 return Py_BuildValue((char *)"");
40742 }
40743 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40744 PyObject *resultobj;
40745 int arg1 = (int) 1 ;
40746 int arg2 = (int) 0 ;
40747 int arg3 = (int) 0 ;
40748 int arg4 = (int) 0 ;
40749 wxGridSizer *result;
40750 PyObject * obj0 = 0 ;
40751 PyObject * obj1 = 0 ;
40752 PyObject * obj2 = 0 ;
40753 PyObject * obj3 = 0 ;
40754 char *kwnames[] = {
40755 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40756 };
40757
40758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40759 if (obj0) {
40760 {
40761 arg1 = (int)(SWIG_As_int(obj0));
40762 if (SWIG_arg_fail(1)) SWIG_fail;
40763 }
40764 }
40765 if (obj1) {
40766 {
40767 arg2 = (int)(SWIG_As_int(obj1));
40768 if (SWIG_arg_fail(2)) SWIG_fail;
40769 }
40770 }
40771 if (obj2) {
40772 {
40773 arg3 = (int)(SWIG_As_int(obj2));
40774 if (SWIG_arg_fail(3)) SWIG_fail;
40775 }
40776 }
40777 if (obj3) {
40778 {
40779 arg4 = (int)(SWIG_As_int(obj3));
40780 if (SWIG_arg_fail(4)) SWIG_fail;
40781 }
40782 }
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40786
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40791 return resultobj;
40792 fail:
40793 return NULL;
40794 }
40795
40796
40797 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40798 PyObject *resultobj;
40799 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40800 int arg2 ;
40801 PyObject * obj0 = 0 ;
40802 PyObject * obj1 = 0 ;
40803 char *kwnames[] = {
40804 (char *) "self",(char *) "cols", NULL
40805 };
40806
40807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40809 if (SWIG_arg_fail(1)) SWIG_fail;
40810 {
40811 arg2 = (int)(SWIG_As_int(obj1));
40812 if (SWIG_arg_fail(2)) SWIG_fail;
40813 }
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 (arg1)->SetCols(arg2);
40817
40818 wxPyEndAllowThreads(__tstate);
40819 if (PyErr_Occurred()) SWIG_fail;
40820 }
40821 Py_INCREF(Py_None); resultobj = Py_None;
40822 return resultobj;
40823 fail:
40824 return NULL;
40825 }
40826
40827
40828 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40829 PyObject *resultobj;
40830 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40831 int arg2 ;
40832 PyObject * obj0 = 0 ;
40833 PyObject * obj1 = 0 ;
40834 char *kwnames[] = {
40835 (char *) "self",(char *) "rows", NULL
40836 };
40837
40838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40840 if (SWIG_arg_fail(1)) SWIG_fail;
40841 {
40842 arg2 = (int)(SWIG_As_int(obj1));
40843 if (SWIG_arg_fail(2)) SWIG_fail;
40844 }
40845 {
40846 PyThreadState* __tstate = wxPyBeginAllowThreads();
40847 (arg1)->SetRows(arg2);
40848
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 Py_INCREF(Py_None); resultobj = Py_None;
40853 return resultobj;
40854 fail:
40855 return NULL;
40856 }
40857
40858
40859 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40860 PyObject *resultobj;
40861 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40862 int arg2 ;
40863 PyObject * obj0 = 0 ;
40864 PyObject * obj1 = 0 ;
40865 char *kwnames[] = {
40866 (char *) "self",(char *) "gap", NULL
40867 };
40868
40869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40871 if (SWIG_arg_fail(1)) SWIG_fail;
40872 {
40873 arg2 = (int)(SWIG_As_int(obj1));
40874 if (SWIG_arg_fail(2)) SWIG_fail;
40875 }
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 (arg1)->SetVGap(arg2);
40879
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 Py_INCREF(Py_None); resultobj = Py_None;
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj;
40892 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40893 int arg2 ;
40894 PyObject * obj0 = 0 ;
40895 PyObject * obj1 = 0 ;
40896 char *kwnames[] = {
40897 (char *) "self",(char *) "gap", NULL
40898 };
40899
40900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40902 if (SWIG_arg_fail(1)) SWIG_fail;
40903 {
40904 arg2 = (int)(SWIG_As_int(obj1));
40905 if (SWIG_arg_fail(2)) SWIG_fail;
40906 }
40907 {
40908 PyThreadState* __tstate = wxPyBeginAllowThreads();
40909 (arg1)->SetHGap(arg2);
40910
40911 wxPyEndAllowThreads(__tstate);
40912 if (PyErr_Occurred()) SWIG_fail;
40913 }
40914 Py_INCREF(Py_None); resultobj = Py_None;
40915 return resultobj;
40916 fail:
40917 return NULL;
40918 }
40919
40920
40921 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40922 PyObject *resultobj;
40923 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40924 int result;
40925 PyObject * obj0 = 0 ;
40926 char *kwnames[] = {
40927 (char *) "self", NULL
40928 };
40929
40930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40932 if (SWIG_arg_fail(1)) SWIG_fail;
40933 {
40934 PyThreadState* __tstate = wxPyBeginAllowThreads();
40935 result = (int)(arg1)->GetCols();
40936
40937 wxPyEndAllowThreads(__tstate);
40938 if (PyErr_Occurred()) SWIG_fail;
40939 }
40940 {
40941 resultobj = SWIG_From_int((int)(result));
40942 }
40943 return resultobj;
40944 fail:
40945 return NULL;
40946 }
40947
40948
40949 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40950 PyObject *resultobj;
40951 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40952 int result;
40953 PyObject * obj0 = 0 ;
40954 char *kwnames[] = {
40955 (char *) "self", NULL
40956 };
40957
40958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40960 if (SWIG_arg_fail(1)) SWIG_fail;
40961 {
40962 PyThreadState* __tstate = wxPyBeginAllowThreads();
40963 result = (int)(arg1)->GetRows();
40964
40965 wxPyEndAllowThreads(__tstate);
40966 if (PyErr_Occurred()) SWIG_fail;
40967 }
40968 {
40969 resultobj = SWIG_From_int((int)(result));
40970 }
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj;
40979 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40980 int result;
40981 PyObject * obj0 = 0 ;
40982 char *kwnames[] = {
40983 (char *) "self", NULL
40984 };
40985
40986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40988 if (SWIG_arg_fail(1)) SWIG_fail;
40989 {
40990 PyThreadState* __tstate = wxPyBeginAllowThreads();
40991 result = (int)(arg1)->GetVGap();
40992
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 {
40997 resultobj = SWIG_From_int((int)(result));
40998 }
40999 return resultobj;
41000 fail:
41001 return NULL;
41002 }
41003
41004
41005 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41006 PyObject *resultobj;
41007 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41008 int result;
41009 PyObject * obj0 = 0 ;
41010 char *kwnames[] = {
41011 (char *) "self", NULL
41012 };
41013
41014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41016 if (SWIG_arg_fail(1)) SWIG_fail;
41017 {
41018 PyThreadState* __tstate = wxPyBeginAllowThreads();
41019 result = (int)(arg1)->GetHGap();
41020
41021 wxPyEndAllowThreads(__tstate);
41022 if (PyErr_Occurred()) SWIG_fail;
41023 }
41024 {
41025 resultobj = SWIG_From_int((int)(result));
41026 }
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41034 PyObject *obj;
41035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41036 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41037 Py_INCREF(obj);
41038 return Py_BuildValue((char *)"");
41039 }
41040 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41041 PyObject *resultobj;
41042 int arg1 = (int) 1 ;
41043 int arg2 = (int) 0 ;
41044 int arg3 = (int) 0 ;
41045 int arg4 = (int) 0 ;
41046 wxFlexGridSizer *result;
41047 PyObject * obj0 = 0 ;
41048 PyObject * obj1 = 0 ;
41049 PyObject * obj2 = 0 ;
41050 PyObject * obj3 = 0 ;
41051 char *kwnames[] = {
41052 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41053 };
41054
41055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41056 if (obj0) {
41057 {
41058 arg1 = (int)(SWIG_As_int(obj0));
41059 if (SWIG_arg_fail(1)) SWIG_fail;
41060 }
41061 }
41062 if (obj1) {
41063 {
41064 arg2 = (int)(SWIG_As_int(obj1));
41065 if (SWIG_arg_fail(2)) SWIG_fail;
41066 }
41067 }
41068 if (obj2) {
41069 {
41070 arg3 = (int)(SWIG_As_int(obj2));
41071 if (SWIG_arg_fail(3)) SWIG_fail;
41072 }
41073 }
41074 if (obj3) {
41075 {
41076 arg4 = (int)(SWIG_As_int(obj3));
41077 if (SWIG_arg_fail(4)) SWIG_fail;
41078 }
41079 }
41080 {
41081 PyThreadState* __tstate = wxPyBeginAllowThreads();
41082 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41083
41084 wxPyEndAllowThreads(__tstate);
41085 if (PyErr_Occurred()) SWIG_fail;
41086 }
41087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41088 return resultobj;
41089 fail:
41090 return NULL;
41091 }
41092
41093
41094 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41095 PyObject *resultobj;
41096 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41097 size_t arg2 ;
41098 int arg3 = (int) 0 ;
41099 PyObject * obj0 = 0 ;
41100 PyObject * obj1 = 0 ;
41101 PyObject * obj2 = 0 ;
41102 char *kwnames[] = {
41103 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41104 };
41105
41106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41108 if (SWIG_arg_fail(1)) SWIG_fail;
41109 {
41110 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41111 if (SWIG_arg_fail(2)) SWIG_fail;
41112 }
41113 if (obj2) {
41114 {
41115 arg3 = (int)(SWIG_As_int(obj2));
41116 if (SWIG_arg_fail(3)) SWIG_fail;
41117 }
41118 }
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 (arg1)->AddGrowableRow(arg2,arg3);
41122
41123 wxPyEndAllowThreads(__tstate);
41124 if (PyErr_Occurred()) SWIG_fail;
41125 }
41126 Py_INCREF(Py_None); resultobj = Py_None;
41127 return resultobj;
41128 fail:
41129 return NULL;
41130 }
41131
41132
41133 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41134 PyObject *resultobj;
41135 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41136 size_t arg2 ;
41137 PyObject * obj0 = 0 ;
41138 PyObject * obj1 = 0 ;
41139 char *kwnames[] = {
41140 (char *) "self",(char *) "idx", NULL
41141 };
41142
41143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41145 if (SWIG_arg_fail(1)) SWIG_fail;
41146 {
41147 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41148 if (SWIG_arg_fail(2)) SWIG_fail;
41149 }
41150 {
41151 PyThreadState* __tstate = wxPyBeginAllowThreads();
41152 (arg1)->RemoveGrowableRow(arg2);
41153
41154 wxPyEndAllowThreads(__tstate);
41155 if (PyErr_Occurred()) SWIG_fail;
41156 }
41157 Py_INCREF(Py_None); resultobj = Py_None;
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41165 PyObject *resultobj;
41166 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41167 size_t arg2 ;
41168 int arg3 = (int) 0 ;
41169 PyObject * obj0 = 0 ;
41170 PyObject * obj1 = 0 ;
41171 PyObject * obj2 = 0 ;
41172 char *kwnames[] = {
41173 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41174 };
41175
41176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41178 if (SWIG_arg_fail(1)) SWIG_fail;
41179 {
41180 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41181 if (SWIG_arg_fail(2)) SWIG_fail;
41182 }
41183 if (obj2) {
41184 {
41185 arg3 = (int)(SWIG_As_int(obj2));
41186 if (SWIG_arg_fail(3)) SWIG_fail;
41187 }
41188 }
41189 {
41190 PyThreadState* __tstate = wxPyBeginAllowThreads();
41191 (arg1)->AddGrowableCol(arg2,arg3);
41192
41193 wxPyEndAllowThreads(__tstate);
41194 if (PyErr_Occurred()) SWIG_fail;
41195 }
41196 Py_INCREF(Py_None); resultobj = Py_None;
41197 return resultobj;
41198 fail:
41199 return NULL;
41200 }
41201
41202
41203 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41204 PyObject *resultobj;
41205 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41206 size_t arg2 ;
41207 PyObject * obj0 = 0 ;
41208 PyObject * obj1 = 0 ;
41209 char *kwnames[] = {
41210 (char *) "self",(char *) "idx", NULL
41211 };
41212
41213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41215 if (SWIG_arg_fail(1)) SWIG_fail;
41216 {
41217 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41218 if (SWIG_arg_fail(2)) SWIG_fail;
41219 }
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 (arg1)->RemoveGrowableCol(arg2);
41223
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 Py_INCREF(Py_None); resultobj = Py_None;
41228 return resultobj;
41229 fail:
41230 return NULL;
41231 }
41232
41233
41234 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41235 PyObject *resultobj;
41236 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41237 int arg2 ;
41238 PyObject * obj0 = 0 ;
41239 PyObject * obj1 = 0 ;
41240 char *kwnames[] = {
41241 (char *) "self",(char *) "direction", NULL
41242 };
41243
41244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41246 if (SWIG_arg_fail(1)) SWIG_fail;
41247 {
41248 arg2 = (int)(SWIG_As_int(obj1));
41249 if (SWIG_arg_fail(2)) SWIG_fail;
41250 }
41251 {
41252 PyThreadState* __tstate = wxPyBeginAllowThreads();
41253 (arg1)->SetFlexibleDirection(arg2);
41254
41255 wxPyEndAllowThreads(__tstate);
41256 if (PyErr_Occurred()) SWIG_fail;
41257 }
41258 Py_INCREF(Py_None); resultobj = Py_None;
41259 return resultobj;
41260 fail:
41261 return NULL;
41262 }
41263
41264
41265 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41266 PyObject *resultobj;
41267 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41268 int result;
41269 PyObject * obj0 = 0 ;
41270 char *kwnames[] = {
41271 (char *) "self", NULL
41272 };
41273
41274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41276 if (SWIG_arg_fail(1)) SWIG_fail;
41277 {
41278 PyThreadState* __tstate = wxPyBeginAllowThreads();
41279 result = (int)(arg1)->GetFlexibleDirection();
41280
41281 wxPyEndAllowThreads(__tstate);
41282 if (PyErr_Occurred()) SWIG_fail;
41283 }
41284 {
41285 resultobj = SWIG_From_int((int)(result));
41286 }
41287 return resultobj;
41288 fail:
41289 return NULL;
41290 }
41291
41292
41293 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41294 PyObject *resultobj;
41295 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41296 wxFlexSizerGrowMode arg2 ;
41297 PyObject * obj0 = 0 ;
41298 PyObject * obj1 = 0 ;
41299 char *kwnames[] = {
41300 (char *) "self",(char *) "mode", NULL
41301 };
41302
41303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41305 if (SWIG_arg_fail(1)) SWIG_fail;
41306 {
41307 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41308 if (SWIG_arg_fail(2)) SWIG_fail;
41309 }
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41313
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 Py_INCREF(Py_None); resultobj = Py_None;
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj;
41326 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41327 wxFlexSizerGrowMode result;
41328 PyObject * obj0 = 0 ;
41329 char *kwnames[] = {
41330 (char *) "self", NULL
41331 };
41332
41333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41335 if (SWIG_arg_fail(1)) SWIG_fail;
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41339
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 resultobj = SWIG_From_int((result));
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41351 PyObject *resultobj;
41352 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41353 wxArrayInt *result;
41354 PyObject * obj0 = 0 ;
41355 char *kwnames[] = {
41356 (char *) "self", NULL
41357 };
41358
41359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41361 if (SWIG_arg_fail(1)) SWIG_fail;
41362 {
41363 PyThreadState* __tstate = wxPyBeginAllowThreads();
41364 {
41365 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41366 result = (wxArrayInt *) &_result_ref;
41367 }
41368
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 {
41373 resultobj = PyList_New(0);
41374 size_t idx;
41375 for (idx = 0; idx < result->GetCount(); idx += 1) {
41376 PyObject* val = PyInt_FromLong( result->Item(idx) );
41377 PyList_Append(resultobj, val);
41378 Py_DECREF(val);
41379 }
41380 }
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj;
41389 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41390 wxArrayInt *result;
41391 PyObject * obj0 = 0 ;
41392 char *kwnames[] = {
41393 (char *) "self", NULL
41394 };
41395
41396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41398 if (SWIG_arg_fail(1)) SWIG_fail;
41399 {
41400 PyThreadState* __tstate = wxPyBeginAllowThreads();
41401 {
41402 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41403 result = (wxArrayInt *) &_result_ref;
41404 }
41405
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = PyList_New(0);
41411 size_t idx;
41412 for (idx = 0; idx < result->GetCount(); idx += 1) {
41413 PyObject* val = PyInt_FromLong( result->Item(idx) );
41414 PyList_Append(resultobj, val);
41415 Py_DECREF(val);
41416 }
41417 }
41418 return resultobj;
41419 fail:
41420 return NULL;
41421 }
41422
41423
41424 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41425 PyObject *obj;
41426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41427 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41428 Py_INCREF(obj);
41429 return Py_BuildValue((char *)"");
41430 }
41431 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj;
41433 wxStdDialogButtonSizer *result;
41434 char *kwnames[] = {
41435 NULL
41436 };
41437
41438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41442
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41447 return resultobj;
41448 fail:
41449 return NULL;
41450 }
41451
41452
41453 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41454 PyObject *resultobj;
41455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41456 wxButton *arg2 = (wxButton *) 0 ;
41457 PyObject * obj0 = 0 ;
41458 PyObject * obj1 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self",(char *) "button", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41467 if (SWIG_arg_fail(2)) SWIG_fail;
41468 {
41469 PyThreadState* __tstate = wxPyBeginAllowThreads();
41470 (arg1)->AddButton(arg2);
41471
41472 wxPyEndAllowThreads(__tstate);
41473 if (PyErr_Occurred()) SWIG_fail;
41474 }
41475 Py_INCREF(Py_None); resultobj = Py_None;
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41483 PyObject *resultobj;
41484 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41485 PyObject * obj0 = 0 ;
41486 char *kwnames[] = {
41487 (char *) "self", NULL
41488 };
41489
41490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41492 if (SWIG_arg_fail(1)) SWIG_fail;
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 (arg1)->Realize();
41496
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 Py_INCREF(Py_None); resultobj = Py_None;
41501 return resultobj;
41502 fail:
41503 return NULL;
41504 }
41505
41506
41507 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41508 PyObject *resultobj;
41509 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41510 wxButton *arg2 = (wxButton *) 0 ;
41511 PyObject * obj0 = 0 ;
41512 PyObject * obj1 = 0 ;
41513 char *kwnames[] = {
41514 (char *) "self",(char *) "button", NULL
41515 };
41516
41517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41519 if (SWIG_arg_fail(1)) SWIG_fail;
41520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41521 if (SWIG_arg_fail(2)) SWIG_fail;
41522 {
41523 PyThreadState* __tstate = wxPyBeginAllowThreads();
41524 (arg1)->SetAffirmativeButton(arg2);
41525
41526 wxPyEndAllowThreads(__tstate);
41527 if (PyErr_Occurred()) SWIG_fail;
41528 }
41529 Py_INCREF(Py_None); resultobj = Py_None;
41530 return resultobj;
41531 fail:
41532 return NULL;
41533 }
41534
41535
41536 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41537 PyObject *resultobj;
41538 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41539 wxButton *arg2 = (wxButton *) 0 ;
41540 PyObject * obj0 = 0 ;
41541 PyObject * obj1 = 0 ;
41542 char *kwnames[] = {
41543 (char *) "self",(char *) "button", NULL
41544 };
41545
41546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41548 if (SWIG_arg_fail(1)) SWIG_fail;
41549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41550 if (SWIG_arg_fail(2)) SWIG_fail;
41551 {
41552 PyThreadState* __tstate = wxPyBeginAllowThreads();
41553 (arg1)->SetNegativeButton(arg2);
41554
41555 wxPyEndAllowThreads(__tstate);
41556 if (PyErr_Occurred()) SWIG_fail;
41557 }
41558 Py_INCREF(Py_None); resultobj = Py_None;
41559 return resultobj;
41560 fail:
41561 return NULL;
41562 }
41563
41564
41565 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41566 PyObject *resultobj;
41567 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41568 wxButton *arg2 = (wxButton *) 0 ;
41569 PyObject * obj0 = 0 ;
41570 PyObject * obj1 = 0 ;
41571 char *kwnames[] = {
41572 (char *) "self",(char *) "button", NULL
41573 };
41574
41575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41577 if (SWIG_arg_fail(1)) SWIG_fail;
41578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41579 if (SWIG_arg_fail(2)) SWIG_fail;
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 (arg1)->SetCancelButton(arg2);
41583
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 Py_INCREF(Py_None); resultobj = Py_None;
41588 return resultobj;
41589 fail:
41590 return NULL;
41591 }
41592
41593
41594 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41595 PyObject *resultobj;
41596 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41597 wxButton *result;
41598 PyObject * obj0 = 0 ;
41599 char *kwnames[] = {
41600 (char *) "self", NULL
41601 };
41602
41603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41605 if (SWIG_arg_fail(1)) SWIG_fail;
41606 {
41607 PyThreadState* __tstate = wxPyBeginAllowThreads();
41608 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41609
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 {
41614 resultobj = wxPyMake_wxObject(result, 0);
41615 }
41616 return resultobj;
41617 fail:
41618 return NULL;
41619 }
41620
41621
41622 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41623 PyObject *resultobj;
41624 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41625 wxButton *result;
41626 PyObject * obj0 = 0 ;
41627 char *kwnames[] = {
41628 (char *) "self", NULL
41629 };
41630
41631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41633 if (SWIG_arg_fail(1)) SWIG_fail;
41634 {
41635 PyThreadState* __tstate = wxPyBeginAllowThreads();
41636 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41637
41638 wxPyEndAllowThreads(__tstate);
41639 if (PyErr_Occurred()) SWIG_fail;
41640 }
41641 {
41642 resultobj = wxPyMake_wxObject(result, 0);
41643 }
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41651 PyObject *resultobj;
41652 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41653 wxButton *result;
41654 PyObject * obj0 = 0 ;
41655 char *kwnames[] = {
41656 (char *) "self", NULL
41657 };
41658
41659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41661 if (SWIG_arg_fail(1)) SWIG_fail;
41662 {
41663 PyThreadState* __tstate = wxPyBeginAllowThreads();
41664 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41665
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 {
41670 resultobj = wxPyMake_wxObject(result, 0);
41671 }
41672 return resultobj;
41673 fail:
41674 return NULL;
41675 }
41676
41677
41678 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41679 PyObject *resultobj;
41680 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41681 wxButton *result;
41682 PyObject * obj0 = 0 ;
41683 char *kwnames[] = {
41684 (char *) "self", NULL
41685 };
41686
41687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41689 if (SWIG_arg_fail(1)) SWIG_fail;
41690 {
41691 PyThreadState* __tstate = wxPyBeginAllowThreads();
41692 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41693
41694 wxPyEndAllowThreads(__tstate);
41695 if (PyErr_Occurred()) SWIG_fail;
41696 }
41697 {
41698 resultobj = wxPyMake_wxObject(result, 0);
41699 }
41700 return resultobj;
41701 fail:
41702 return NULL;
41703 }
41704
41705
41706 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41707 PyObject *resultobj;
41708 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41709 wxButton *result;
41710 PyObject * obj0 = 0 ;
41711 char *kwnames[] = {
41712 (char *) "self", NULL
41713 };
41714
41715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41717 if (SWIG_arg_fail(1)) SWIG_fail;
41718 {
41719 PyThreadState* __tstate = wxPyBeginAllowThreads();
41720 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41721
41722 wxPyEndAllowThreads(__tstate);
41723 if (PyErr_Occurred()) SWIG_fail;
41724 }
41725 {
41726 resultobj = wxPyMake_wxObject(result, 0);
41727 }
41728 return resultobj;
41729 fail:
41730 return NULL;
41731 }
41732
41733
41734 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41735 PyObject *obj;
41736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41737 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41738 Py_INCREF(obj);
41739 return Py_BuildValue((char *)"");
41740 }
41741 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj;
41743 int arg1 = (int) 0 ;
41744 int arg2 = (int) 0 ;
41745 wxGBPosition *result;
41746 PyObject * obj0 = 0 ;
41747 PyObject * obj1 = 0 ;
41748 char *kwnames[] = {
41749 (char *) "row",(char *) "col", NULL
41750 };
41751
41752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41753 if (obj0) {
41754 {
41755 arg1 = (int)(SWIG_As_int(obj0));
41756 if (SWIG_arg_fail(1)) SWIG_fail;
41757 }
41758 }
41759 if (obj1) {
41760 {
41761 arg2 = (int)(SWIG_As_int(obj1));
41762 if (SWIG_arg_fail(2)) SWIG_fail;
41763 }
41764 }
41765 {
41766 PyThreadState* __tstate = wxPyBeginAllowThreads();
41767 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41768
41769 wxPyEndAllowThreads(__tstate);
41770 if (PyErr_Occurred()) SWIG_fail;
41771 }
41772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41773 return resultobj;
41774 fail:
41775 return NULL;
41776 }
41777
41778
41779 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41780 PyObject *resultobj;
41781 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41782 int result;
41783 PyObject * obj0 = 0 ;
41784 char *kwnames[] = {
41785 (char *) "self", NULL
41786 };
41787
41788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41790 if (SWIG_arg_fail(1)) SWIG_fail;
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 result = (int)((wxGBPosition const *)arg1)->GetRow();
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 {
41799 resultobj = SWIG_From_int((int)(result));
41800 }
41801 return resultobj;
41802 fail:
41803 return NULL;
41804 }
41805
41806
41807 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41808 PyObject *resultobj;
41809 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41810 int result;
41811 PyObject * obj0 = 0 ;
41812 char *kwnames[] = {
41813 (char *) "self", NULL
41814 };
41815
41816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41818 if (SWIG_arg_fail(1)) SWIG_fail;
41819 {
41820 PyThreadState* __tstate = wxPyBeginAllowThreads();
41821 result = (int)((wxGBPosition const *)arg1)->GetCol();
41822
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 {
41827 resultobj = SWIG_From_int((int)(result));
41828 }
41829 return resultobj;
41830 fail:
41831 return NULL;
41832 }
41833
41834
41835 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41836 PyObject *resultobj;
41837 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41838 int arg2 ;
41839 PyObject * obj0 = 0 ;
41840 PyObject * obj1 = 0 ;
41841 char *kwnames[] = {
41842 (char *) "self",(char *) "row", NULL
41843 };
41844
41845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41847 if (SWIG_arg_fail(1)) SWIG_fail;
41848 {
41849 arg2 = (int)(SWIG_As_int(obj1));
41850 if (SWIG_arg_fail(2)) SWIG_fail;
41851 }
41852 {
41853 PyThreadState* __tstate = wxPyBeginAllowThreads();
41854 (arg1)->SetRow(arg2);
41855
41856 wxPyEndAllowThreads(__tstate);
41857 if (PyErr_Occurred()) SWIG_fail;
41858 }
41859 Py_INCREF(Py_None); resultobj = Py_None;
41860 return resultobj;
41861 fail:
41862 return NULL;
41863 }
41864
41865
41866 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41867 PyObject *resultobj;
41868 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41869 int arg2 ;
41870 PyObject * obj0 = 0 ;
41871 PyObject * obj1 = 0 ;
41872 char *kwnames[] = {
41873 (char *) "self",(char *) "col", NULL
41874 };
41875
41876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41878 if (SWIG_arg_fail(1)) SWIG_fail;
41879 {
41880 arg2 = (int)(SWIG_As_int(obj1));
41881 if (SWIG_arg_fail(2)) SWIG_fail;
41882 }
41883 {
41884 PyThreadState* __tstate = wxPyBeginAllowThreads();
41885 (arg1)->SetCol(arg2);
41886
41887 wxPyEndAllowThreads(__tstate);
41888 if (PyErr_Occurred()) SWIG_fail;
41889 }
41890 Py_INCREF(Py_None); resultobj = Py_None;
41891 return resultobj;
41892 fail:
41893 return NULL;
41894 }
41895
41896
41897 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41898 PyObject *resultobj;
41899 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41900 wxGBPosition *arg2 = 0 ;
41901 bool result;
41902 wxGBPosition temp2 ;
41903 PyObject * obj0 = 0 ;
41904 PyObject * obj1 = 0 ;
41905 char *kwnames[] = {
41906 (char *) "self",(char *) "other", NULL
41907 };
41908
41909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41911 if (SWIG_arg_fail(1)) SWIG_fail;
41912 {
41913 arg2 = &temp2;
41914 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41915 }
41916 {
41917 PyThreadState* __tstate = wxPyBeginAllowThreads();
41918 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41919
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 {
41924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41925 }
41926 return resultobj;
41927 fail:
41928 return NULL;
41929 }
41930
41931
41932 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41933 PyObject *resultobj;
41934 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41935 wxGBPosition *arg2 = 0 ;
41936 bool result;
41937 wxGBPosition temp2 ;
41938 PyObject * obj0 = 0 ;
41939 PyObject * obj1 = 0 ;
41940 char *kwnames[] = {
41941 (char *) "self",(char *) "other", NULL
41942 };
41943
41944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41946 if (SWIG_arg_fail(1)) SWIG_fail;
41947 {
41948 arg2 = &temp2;
41949 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41950 }
41951 {
41952 PyThreadState* __tstate = wxPyBeginAllowThreads();
41953 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41954
41955 wxPyEndAllowThreads(__tstate);
41956 if (PyErr_Occurred()) SWIG_fail;
41957 }
41958 {
41959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41960 }
41961 return resultobj;
41962 fail:
41963 return NULL;
41964 }
41965
41966
41967 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41968 PyObject *resultobj;
41969 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41970 int arg2 = (int) 0 ;
41971 int arg3 = (int) 0 ;
41972 PyObject * obj0 = 0 ;
41973 PyObject * obj1 = 0 ;
41974 PyObject * obj2 = 0 ;
41975 char *kwnames[] = {
41976 (char *) "self",(char *) "row",(char *) "col", NULL
41977 };
41978
41979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41981 if (SWIG_arg_fail(1)) SWIG_fail;
41982 if (obj1) {
41983 {
41984 arg2 = (int)(SWIG_As_int(obj1));
41985 if (SWIG_arg_fail(2)) SWIG_fail;
41986 }
41987 }
41988 if (obj2) {
41989 {
41990 arg3 = (int)(SWIG_As_int(obj2));
41991 if (SWIG_arg_fail(3)) SWIG_fail;
41992 }
41993 }
41994 {
41995 PyThreadState* __tstate = wxPyBeginAllowThreads();
41996 wxGBPosition_Set(arg1,arg2,arg3);
41997
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 Py_INCREF(Py_None); resultobj = Py_None;
42002 return resultobj;
42003 fail:
42004 return NULL;
42005 }
42006
42007
42008 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42009 PyObject *resultobj;
42010 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42011 PyObject *result;
42012 PyObject * obj0 = 0 ;
42013 char *kwnames[] = {
42014 (char *) "self", NULL
42015 };
42016
42017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42019 if (SWIG_arg_fail(1)) SWIG_fail;
42020 {
42021 PyThreadState* __tstate = wxPyBeginAllowThreads();
42022 result = (PyObject *)wxGBPosition_Get(arg1);
42023
42024 wxPyEndAllowThreads(__tstate);
42025 if (PyErr_Occurred()) SWIG_fail;
42026 }
42027 resultobj = result;
42028 return resultobj;
42029 fail:
42030 return NULL;
42031 }
42032
42033
42034 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42035 PyObject *obj;
42036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42037 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42038 Py_INCREF(obj);
42039 return Py_BuildValue((char *)"");
42040 }
42041 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42042 PyObject *resultobj;
42043 int arg1 = (int) 1 ;
42044 int arg2 = (int) 1 ;
42045 wxGBSpan *result;
42046 PyObject * obj0 = 0 ;
42047 PyObject * obj1 = 0 ;
42048 char *kwnames[] = {
42049 (char *) "rowspan",(char *) "colspan", NULL
42050 };
42051
42052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42053 if (obj0) {
42054 {
42055 arg1 = (int)(SWIG_As_int(obj0));
42056 if (SWIG_arg_fail(1)) SWIG_fail;
42057 }
42058 }
42059 if (obj1) {
42060 {
42061 arg2 = (int)(SWIG_As_int(obj1));
42062 if (SWIG_arg_fail(2)) SWIG_fail;
42063 }
42064 }
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42068
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42073 return resultobj;
42074 fail:
42075 return NULL;
42076 }
42077
42078
42079 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42080 PyObject *resultobj;
42081 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42082 int result;
42083 PyObject * obj0 = 0 ;
42084 char *kwnames[] = {
42085 (char *) "self", NULL
42086 };
42087
42088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42090 if (SWIG_arg_fail(1)) SWIG_fail;
42091 {
42092 PyThreadState* __tstate = wxPyBeginAllowThreads();
42093 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42094
42095 wxPyEndAllowThreads(__tstate);
42096 if (PyErr_Occurred()) SWIG_fail;
42097 }
42098 {
42099 resultobj = SWIG_From_int((int)(result));
42100 }
42101 return resultobj;
42102 fail:
42103 return NULL;
42104 }
42105
42106
42107 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42108 PyObject *resultobj;
42109 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42110 int result;
42111 PyObject * obj0 = 0 ;
42112 char *kwnames[] = {
42113 (char *) "self", NULL
42114 };
42115
42116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42118 if (SWIG_arg_fail(1)) SWIG_fail;
42119 {
42120 PyThreadState* __tstate = wxPyBeginAllowThreads();
42121 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42122
42123 wxPyEndAllowThreads(__tstate);
42124 if (PyErr_Occurred()) SWIG_fail;
42125 }
42126 {
42127 resultobj = SWIG_From_int((int)(result));
42128 }
42129 return resultobj;
42130 fail:
42131 return NULL;
42132 }
42133
42134
42135 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42136 PyObject *resultobj;
42137 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42138 int arg2 ;
42139 PyObject * obj0 = 0 ;
42140 PyObject * obj1 = 0 ;
42141 char *kwnames[] = {
42142 (char *) "self",(char *) "rowspan", NULL
42143 };
42144
42145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42147 if (SWIG_arg_fail(1)) SWIG_fail;
42148 {
42149 arg2 = (int)(SWIG_As_int(obj1));
42150 if (SWIG_arg_fail(2)) SWIG_fail;
42151 }
42152 {
42153 PyThreadState* __tstate = wxPyBeginAllowThreads();
42154 (arg1)->SetRowspan(arg2);
42155
42156 wxPyEndAllowThreads(__tstate);
42157 if (PyErr_Occurred()) SWIG_fail;
42158 }
42159 Py_INCREF(Py_None); resultobj = Py_None;
42160 return resultobj;
42161 fail:
42162 return NULL;
42163 }
42164
42165
42166 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42167 PyObject *resultobj;
42168 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42169 int arg2 ;
42170 PyObject * obj0 = 0 ;
42171 PyObject * obj1 = 0 ;
42172 char *kwnames[] = {
42173 (char *) "self",(char *) "colspan", NULL
42174 };
42175
42176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42178 if (SWIG_arg_fail(1)) SWIG_fail;
42179 {
42180 arg2 = (int)(SWIG_As_int(obj1));
42181 if (SWIG_arg_fail(2)) SWIG_fail;
42182 }
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 (arg1)->SetColspan(arg2);
42186
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 Py_INCREF(Py_None); resultobj = Py_None;
42191 return resultobj;
42192 fail:
42193 return NULL;
42194 }
42195
42196
42197 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42198 PyObject *resultobj;
42199 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42200 wxGBSpan *arg2 = 0 ;
42201 bool result;
42202 wxGBSpan temp2 ;
42203 PyObject * obj0 = 0 ;
42204 PyObject * obj1 = 0 ;
42205 char *kwnames[] = {
42206 (char *) "self",(char *) "other", NULL
42207 };
42208
42209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42211 if (SWIG_arg_fail(1)) SWIG_fail;
42212 {
42213 arg2 = &temp2;
42214 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42215 }
42216 {
42217 PyThreadState* __tstate = wxPyBeginAllowThreads();
42218 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42219
42220 wxPyEndAllowThreads(__tstate);
42221 if (PyErr_Occurred()) SWIG_fail;
42222 }
42223 {
42224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42225 }
42226 return resultobj;
42227 fail:
42228 return NULL;
42229 }
42230
42231
42232 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42233 PyObject *resultobj;
42234 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42235 wxGBSpan *arg2 = 0 ;
42236 bool result;
42237 wxGBSpan temp2 ;
42238 PyObject * obj0 = 0 ;
42239 PyObject * obj1 = 0 ;
42240 char *kwnames[] = {
42241 (char *) "self",(char *) "other", NULL
42242 };
42243
42244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42246 if (SWIG_arg_fail(1)) SWIG_fail;
42247 {
42248 arg2 = &temp2;
42249 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42250 }
42251 {
42252 PyThreadState* __tstate = wxPyBeginAllowThreads();
42253 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42254
42255 wxPyEndAllowThreads(__tstate);
42256 if (PyErr_Occurred()) SWIG_fail;
42257 }
42258 {
42259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42260 }
42261 return resultobj;
42262 fail:
42263 return NULL;
42264 }
42265
42266
42267 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42268 PyObject *resultobj;
42269 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42270 int arg2 = (int) 1 ;
42271 int arg3 = (int) 1 ;
42272 PyObject * obj0 = 0 ;
42273 PyObject * obj1 = 0 ;
42274 PyObject * obj2 = 0 ;
42275 char *kwnames[] = {
42276 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42277 };
42278
42279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42281 if (SWIG_arg_fail(1)) SWIG_fail;
42282 if (obj1) {
42283 {
42284 arg2 = (int)(SWIG_As_int(obj1));
42285 if (SWIG_arg_fail(2)) SWIG_fail;
42286 }
42287 }
42288 if (obj2) {
42289 {
42290 arg3 = (int)(SWIG_As_int(obj2));
42291 if (SWIG_arg_fail(3)) SWIG_fail;
42292 }
42293 }
42294 {
42295 PyThreadState* __tstate = wxPyBeginAllowThreads();
42296 wxGBSpan_Set(arg1,arg2,arg3);
42297
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 Py_INCREF(Py_None); resultobj = Py_None;
42302 return resultobj;
42303 fail:
42304 return NULL;
42305 }
42306
42307
42308 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42309 PyObject *resultobj;
42310 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42311 PyObject *result;
42312 PyObject * obj0 = 0 ;
42313 char *kwnames[] = {
42314 (char *) "self", NULL
42315 };
42316
42317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42319 if (SWIG_arg_fail(1)) SWIG_fail;
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (PyObject *)wxGBSpan_Get(arg1);
42323
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 resultobj = result;
42328 return resultobj;
42329 fail:
42330 return NULL;
42331 }
42332
42333
42334 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42335 PyObject *obj;
42336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42337 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42338 Py_INCREF(obj);
42339 return Py_BuildValue((char *)"");
42340 }
42341 static int _wrap_DefaultSpan_set(PyObject *) {
42342 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42343 return 1;
42344 }
42345
42346
42347 static PyObject *_wrap_DefaultSpan_get(void) {
42348 PyObject *pyobj;
42349
42350 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42351 return pyobj;
42352 }
42353
42354
42355 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42356 PyObject *resultobj;
42357 wxGBSizerItem *result;
42358 char *kwnames[] = {
42359 NULL
42360 };
42361
42362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42363 {
42364 PyThreadState* __tstate = wxPyBeginAllowThreads();
42365 result = (wxGBSizerItem *)new wxGBSizerItem();
42366
42367 wxPyEndAllowThreads(__tstate);
42368 if (PyErr_Occurred()) SWIG_fail;
42369 }
42370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42371 return resultobj;
42372 fail:
42373 return NULL;
42374 }
42375
42376
42377 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42378 PyObject *resultobj;
42379 wxWindow *arg1 = (wxWindow *) 0 ;
42380 wxGBPosition *arg2 = 0 ;
42381 wxGBSpan *arg3 = 0 ;
42382 int arg4 ;
42383 int arg5 ;
42384 PyObject *arg6 = (PyObject *) NULL ;
42385 wxGBSizerItem *result;
42386 wxGBPosition temp2 ;
42387 wxGBSpan temp3 ;
42388 PyObject * obj0 = 0 ;
42389 PyObject * obj1 = 0 ;
42390 PyObject * obj2 = 0 ;
42391 PyObject * obj3 = 0 ;
42392 PyObject * obj4 = 0 ;
42393 PyObject * obj5 = 0 ;
42394 char *kwnames[] = {
42395 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42396 };
42397
42398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42400 if (SWIG_arg_fail(1)) SWIG_fail;
42401 {
42402 arg2 = &temp2;
42403 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42404 }
42405 {
42406 arg3 = &temp3;
42407 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42408 }
42409 {
42410 arg4 = (int)(SWIG_As_int(obj3));
42411 if (SWIG_arg_fail(4)) SWIG_fail;
42412 }
42413 {
42414 arg5 = (int)(SWIG_As_int(obj4));
42415 if (SWIG_arg_fail(5)) SWIG_fail;
42416 }
42417 if (obj5) {
42418 arg6 = obj5;
42419 }
42420 {
42421 PyThreadState* __tstate = wxPyBeginAllowThreads();
42422 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42423
42424 wxPyEndAllowThreads(__tstate);
42425 if (PyErr_Occurred()) SWIG_fail;
42426 }
42427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42428 return resultobj;
42429 fail:
42430 return NULL;
42431 }
42432
42433
42434 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42435 PyObject *resultobj;
42436 wxSizer *arg1 = (wxSizer *) 0 ;
42437 wxGBPosition *arg2 = 0 ;
42438 wxGBSpan *arg3 = 0 ;
42439 int arg4 ;
42440 int arg5 ;
42441 PyObject *arg6 = (PyObject *) NULL ;
42442 wxGBSizerItem *result;
42443 wxGBPosition temp2 ;
42444 wxGBSpan temp3 ;
42445 PyObject * obj0 = 0 ;
42446 PyObject * obj1 = 0 ;
42447 PyObject * obj2 = 0 ;
42448 PyObject * obj3 = 0 ;
42449 PyObject * obj4 = 0 ;
42450 PyObject * obj5 = 0 ;
42451 char *kwnames[] = {
42452 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42453 };
42454
42455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42457 if (SWIG_arg_fail(1)) SWIG_fail;
42458 {
42459 arg2 = &temp2;
42460 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42461 }
42462 {
42463 arg3 = &temp3;
42464 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42465 }
42466 {
42467 arg4 = (int)(SWIG_As_int(obj3));
42468 if (SWIG_arg_fail(4)) SWIG_fail;
42469 }
42470 {
42471 arg5 = (int)(SWIG_As_int(obj4));
42472 if (SWIG_arg_fail(5)) SWIG_fail;
42473 }
42474 if (obj5) {
42475 arg6 = obj5;
42476 }
42477 {
42478 PyThreadState* __tstate = wxPyBeginAllowThreads();
42479 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42480
42481 wxPyEndAllowThreads(__tstate);
42482 if (PyErr_Occurred()) SWIG_fail;
42483 }
42484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj;
42493 int arg1 ;
42494 int arg2 ;
42495 wxGBPosition *arg3 = 0 ;
42496 wxGBSpan *arg4 = 0 ;
42497 int arg5 ;
42498 int arg6 ;
42499 PyObject *arg7 = (PyObject *) NULL ;
42500 wxGBSizerItem *result;
42501 wxGBPosition temp3 ;
42502 wxGBSpan temp4 ;
42503 PyObject * obj0 = 0 ;
42504 PyObject * obj1 = 0 ;
42505 PyObject * obj2 = 0 ;
42506 PyObject * obj3 = 0 ;
42507 PyObject * obj4 = 0 ;
42508 PyObject * obj5 = 0 ;
42509 PyObject * obj6 = 0 ;
42510 char *kwnames[] = {
42511 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42512 };
42513
42514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42515 {
42516 arg1 = (int)(SWIG_As_int(obj0));
42517 if (SWIG_arg_fail(1)) SWIG_fail;
42518 }
42519 {
42520 arg2 = (int)(SWIG_As_int(obj1));
42521 if (SWIG_arg_fail(2)) SWIG_fail;
42522 }
42523 {
42524 arg3 = &temp3;
42525 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42526 }
42527 {
42528 arg4 = &temp4;
42529 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42530 }
42531 {
42532 arg5 = (int)(SWIG_As_int(obj4));
42533 if (SWIG_arg_fail(5)) SWIG_fail;
42534 }
42535 {
42536 arg6 = (int)(SWIG_As_int(obj5));
42537 if (SWIG_arg_fail(6)) SWIG_fail;
42538 }
42539 if (obj6) {
42540 arg7 = obj6;
42541 }
42542 {
42543 PyThreadState* __tstate = wxPyBeginAllowThreads();
42544 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42545
42546 wxPyEndAllowThreads(__tstate);
42547 if (PyErr_Occurred()) SWIG_fail;
42548 }
42549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42550 return resultobj;
42551 fail:
42552 return NULL;
42553 }
42554
42555
42556 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42557 PyObject *resultobj;
42558 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42559 wxGBPosition result;
42560 PyObject * obj0 = 0 ;
42561 char *kwnames[] = {
42562 (char *) "self", NULL
42563 };
42564
42565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42567 if (SWIG_arg_fail(1)) SWIG_fail;
42568 {
42569 PyThreadState* __tstate = wxPyBeginAllowThreads();
42570 result = ((wxGBSizerItem const *)arg1)->GetPos();
42571
42572 wxPyEndAllowThreads(__tstate);
42573 if (PyErr_Occurred()) SWIG_fail;
42574 }
42575 {
42576 wxGBPosition * resultptr;
42577 resultptr = new wxGBPosition((wxGBPosition &)(result));
42578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42579 }
42580 return resultobj;
42581 fail:
42582 return NULL;
42583 }
42584
42585
42586 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42587 PyObject *resultobj;
42588 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42589 wxGBSpan result;
42590 PyObject * obj0 = 0 ;
42591 char *kwnames[] = {
42592 (char *) "self", NULL
42593 };
42594
42595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42597 if (SWIG_arg_fail(1)) SWIG_fail;
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42601
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 {
42606 wxGBSpan * resultptr;
42607 resultptr = new wxGBSpan((wxGBSpan &)(result));
42608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42617 PyObject *resultobj;
42618 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42619 wxGBPosition *arg2 = 0 ;
42620 bool result;
42621 wxGBPosition temp2 ;
42622 PyObject * obj0 = 0 ;
42623 PyObject * obj1 = 0 ;
42624 char *kwnames[] = {
42625 (char *) "self",(char *) "pos", NULL
42626 };
42627
42628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42630 if (SWIG_arg_fail(1)) SWIG_fail;
42631 {
42632 arg2 = &temp2;
42633 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42634 }
42635 {
42636 PyThreadState* __tstate = wxPyBeginAllowThreads();
42637 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42638
42639 wxPyEndAllowThreads(__tstate);
42640 if (PyErr_Occurred()) SWIG_fail;
42641 }
42642 {
42643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42644 }
42645 return resultobj;
42646 fail:
42647 return NULL;
42648 }
42649
42650
42651 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42652 PyObject *resultobj;
42653 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42654 wxGBSpan *arg2 = 0 ;
42655 bool result;
42656 wxGBSpan temp2 ;
42657 PyObject * obj0 = 0 ;
42658 PyObject * obj1 = 0 ;
42659 char *kwnames[] = {
42660 (char *) "self",(char *) "span", NULL
42661 };
42662
42663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42665 if (SWIG_arg_fail(1)) SWIG_fail;
42666 {
42667 arg2 = &temp2;
42668 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42669 }
42670 {
42671 PyThreadState* __tstate = wxPyBeginAllowThreads();
42672 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42673
42674 wxPyEndAllowThreads(__tstate);
42675 if (PyErr_Occurred()) SWIG_fail;
42676 }
42677 {
42678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42679 }
42680 return resultobj;
42681 fail:
42682 return NULL;
42683 }
42684
42685
42686 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42687 PyObject *resultobj;
42688 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42689 wxGBSizerItem *arg2 = 0 ;
42690 bool result;
42691 PyObject * obj0 = 0 ;
42692 PyObject * obj1 = 0 ;
42693 char *kwnames[] = {
42694 (char *) "self",(char *) "other", NULL
42695 };
42696
42697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42699 if (SWIG_arg_fail(1)) SWIG_fail;
42700 {
42701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42702 if (SWIG_arg_fail(2)) SWIG_fail;
42703 if (arg2 == NULL) {
42704 SWIG_null_ref("wxGBSizerItem");
42705 }
42706 if (SWIG_arg_fail(2)) SWIG_fail;
42707 }
42708 {
42709 PyThreadState* __tstate = wxPyBeginAllowThreads();
42710 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42711
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 {
42716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42717 }
42718 return resultobj;
42719 fail:
42720 return NULL;
42721 }
42722
42723
42724 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42725 PyObject *resultobj;
42726 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42727 wxGBPosition *arg2 = 0 ;
42728 wxGBSpan *arg3 = 0 ;
42729 bool result;
42730 wxGBPosition temp2 ;
42731 wxGBSpan temp3 ;
42732 PyObject * obj0 = 0 ;
42733 PyObject * obj1 = 0 ;
42734 PyObject * obj2 = 0 ;
42735 char *kwnames[] = {
42736 (char *) "self",(char *) "pos",(char *) "span", NULL
42737 };
42738
42739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42741 if (SWIG_arg_fail(1)) SWIG_fail;
42742 {
42743 arg2 = &temp2;
42744 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42745 }
42746 {
42747 arg3 = &temp3;
42748 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42749 }
42750 {
42751 PyThreadState* __tstate = wxPyBeginAllowThreads();
42752 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42753
42754 wxPyEndAllowThreads(__tstate);
42755 if (PyErr_Occurred()) SWIG_fail;
42756 }
42757 {
42758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42759 }
42760 return resultobj;
42761 fail:
42762 return NULL;
42763 }
42764
42765
42766 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj;
42768 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42769 wxGBPosition result;
42770 PyObject * obj0 = 0 ;
42771 char *kwnames[] = {
42772 (char *) "self", NULL
42773 };
42774
42775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42777 if (SWIG_arg_fail(1)) SWIG_fail;
42778 {
42779 PyThreadState* __tstate = wxPyBeginAllowThreads();
42780 result = wxGBSizerItem_GetEndPos(arg1);
42781
42782 wxPyEndAllowThreads(__tstate);
42783 if (PyErr_Occurred()) SWIG_fail;
42784 }
42785 {
42786 wxGBPosition * resultptr;
42787 resultptr = new wxGBPosition((wxGBPosition &)(result));
42788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj;
42798 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42799 wxGridBagSizer *result;
42800 PyObject * obj0 = 0 ;
42801 char *kwnames[] = {
42802 (char *) "self", NULL
42803 };
42804
42805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42807 if (SWIG_arg_fail(1)) SWIG_fail;
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42811
42812 wxPyEndAllowThreads(__tstate);
42813 if (PyErr_Occurred()) SWIG_fail;
42814 }
42815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj;
42824 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42825 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42826 PyObject * obj0 = 0 ;
42827 PyObject * obj1 = 0 ;
42828 char *kwnames[] = {
42829 (char *) "self",(char *) "sizer", NULL
42830 };
42831
42832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42834 if (SWIG_arg_fail(1)) SWIG_fail;
42835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42836 if (SWIG_arg_fail(2)) SWIG_fail;
42837 {
42838 PyThreadState* __tstate = wxPyBeginAllowThreads();
42839 (arg1)->SetGBSizer(arg2);
42840
42841 wxPyEndAllowThreads(__tstate);
42842 if (PyErr_Occurred()) SWIG_fail;
42843 }
42844 Py_INCREF(Py_None); resultobj = Py_None;
42845 return resultobj;
42846 fail:
42847 return NULL;
42848 }
42849
42850
42851 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42852 PyObject *obj;
42853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42854 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42855 Py_INCREF(obj);
42856 return Py_BuildValue((char *)"");
42857 }
42858 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42859 PyObject *resultobj;
42860 int arg1 = (int) 0 ;
42861 int arg2 = (int) 0 ;
42862 wxGridBagSizer *result;
42863 PyObject * obj0 = 0 ;
42864 PyObject * obj1 = 0 ;
42865 char *kwnames[] = {
42866 (char *) "vgap",(char *) "hgap", NULL
42867 };
42868
42869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42870 if (obj0) {
42871 {
42872 arg1 = (int)(SWIG_As_int(obj0));
42873 if (SWIG_arg_fail(1)) SWIG_fail;
42874 }
42875 }
42876 if (obj1) {
42877 {
42878 arg2 = (int)(SWIG_As_int(obj1));
42879 if (SWIG_arg_fail(2)) SWIG_fail;
42880 }
42881 }
42882 {
42883 PyThreadState* __tstate = wxPyBeginAllowThreads();
42884 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42885
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42897 PyObject *resultobj;
42898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42899 PyObject *arg2 = (PyObject *) 0 ;
42900 wxGBPosition *arg3 = 0 ;
42901 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42902 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42903 int arg5 = (int) 0 ;
42904 int arg6 = (int) 0 ;
42905 PyObject *arg7 = (PyObject *) NULL ;
42906 wxGBSizerItem *result;
42907 wxGBPosition temp3 ;
42908 wxGBSpan temp4 ;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911 PyObject * obj2 = 0 ;
42912 PyObject * obj3 = 0 ;
42913 PyObject * obj4 = 0 ;
42914 PyObject * obj5 = 0 ;
42915 PyObject * obj6 = 0 ;
42916 char *kwnames[] = {
42917 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42918 };
42919
42920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42922 if (SWIG_arg_fail(1)) SWIG_fail;
42923 arg2 = obj1;
42924 {
42925 arg3 = &temp3;
42926 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42927 }
42928 if (obj3) {
42929 {
42930 arg4 = &temp4;
42931 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42932 }
42933 }
42934 if (obj4) {
42935 {
42936 arg5 = (int)(SWIG_As_int(obj4));
42937 if (SWIG_arg_fail(5)) SWIG_fail;
42938 }
42939 }
42940 if (obj5) {
42941 {
42942 arg6 = (int)(SWIG_As_int(obj5));
42943 if (SWIG_arg_fail(6)) SWIG_fail;
42944 }
42945 }
42946 if (obj6) {
42947 arg7 = obj6;
42948 }
42949 {
42950 PyThreadState* __tstate = wxPyBeginAllowThreads();
42951 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42952
42953 wxPyEndAllowThreads(__tstate);
42954 if (PyErr_Occurred()) SWIG_fail;
42955 }
42956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42957 return resultobj;
42958 fail:
42959 return NULL;
42960 }
42961
42962
42963 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42964 PyObject *resultobj;
42965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42966 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42967 wxGBSizerItem *result;
42968 PyObject * obj0 = 0 ;
42969 PyObject * obj1 = 0 ;
42970 char *kwnames[] = {
42971 (char *) "self",(char *) "item", NULL
42972 };
42973
42974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42976 if (SWIG_arg_fail(1)) SWIG_fail;
42977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42978 if (SWIG_arg_fail(2)) SWIG_fail;
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42982
42983 wxPyEndAllowThreads(__tstate);
42984 if (PyErr_Occurred()) SWIG_fail;
42985 }
42986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42987 return resultobj;
42988 fail:
42989 return NULL;
42990 }
42991
42992
42993 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42994 PyObject *resultobj;
42995 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42996 int arg2 ;
42997 int arg3 ;
42998 wxSize result;
42999 PyObject * obj0 = 0 ;
43000 PyObject * obj1 = 0 ;
43001 PyObject * obj2 = 0 ;
43002 char *kwnames[] = {
43003 (char *) "self",(char *) "row",(char *) "col", NULL
43004 };
43005
43006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43008 if (SWIG_arg_fail(1)) SWIG_fail;
43009 {
43010 arg2 = (int)(SWIG_As_int(obj1));
43011 if (SWIG_arg_fail(2)) SWIG_fail;
43012 }
43013 {
43014 arg3 = (int)(SWIG_As_int(obj2));
43015 if (SWIG_arg_fail(3)) SWIG_fail;
43016 }
43017 {
43018 PyThreadState* __tstate = wxPyBeginAllowThreads();
43019 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43020
43021 wxPyEndAllowThreads(__tstate);
43022 if (PyErr_Occurred()) SWIG_fail;
43023 }
43024 {
43025 wxSize * resultptr;
43026 resultptr = new wxSize((wxSize &)(result));
43027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43028 }
43029 return resultobj;
43030 fail:
43031 return NULL;
43032 }
43033
43034
43035 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43036 PyObject *resultobj;
43037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43038 wxSize result;
43039 PyObject * obj0 = 0 ;
43040 char *kwnames[] = {
43041 (char *) "self", NULL
43042 };
43043
43044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43046 if (SWIG_arg_fail(1)) SWIG_fail;
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43050
43051 wxPyEndAllowThreads(__tstate);
43052 if (PyErr_Occurred()) SWIG_fail;
43053 }
43054 {
43055 wxSize * resultptr;
43056 resultptr = new wxSize((wxSize &)(result));
43057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43058 }
43059 return resultobj;
43060 fail:
43061 return NULL;
43062 }
43063
43064
43065 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43066 PyObject *resultobj;
43067 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43068 wxSize *arg2 = 0 ;
43069 wxSize temp2 ;
43070 PyObject * obj0 = 0 ;
43071 PyObject * obj1 = 0 ;
43072 char *kwnames[] = {
43073 (char *) "self",(char *) "sz", NULL
43074 };
43075
43076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43078 if (SWIG_arg_fail(1)) SWIG_fail;
43079 {
43080 arg2 = &temp2;
43081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43082 }
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43086
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 Py_INCREF(Py_None); resultobj = Py_None;
43091 return resultobj;
43092 fail:
43093 return NULL;
43094 }
43095
43096
43097 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43098 PyObject *resultobj;
43099 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43100 wxWindow *arg2 = (wxWindow *) 0 ;
43101 wxGBPosition result;
43102 PyObject * obj0 = 0 ;
43103 PyObject * obj1 = 0 ;
43104
43105 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(2)) SWIG_fail;
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (arg1)->GetItemPosition(arg2);
43113
43114 wxPyEndAllowThreads(__tstate);
43115 if (PyErr_Occurred()) SWIG_fail;
43116 }
43117 {
43118 wxGBPosition * resultptr;
43119 resultptr = new wxGBPosition((wxGBPosition &)(result));
43120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43121 }
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43129 PyObject *resultobj;
43130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43131 wxSizer *arg2 = (wxSizer *) 0 ;
43132 wxGBPosition result;
43133 PyObject * obj0 = 0 ;
43134 PyObject * obj1 = 0 ;
43135
43136 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43138 if (SWIG_arg_fail(1)) SWIG_fail;
43139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43140 if (SWIG_arg_fail(2)) SWIG_fail;
43141 {
43142 PyThreadState* __tstate = wxPyBeginAllowThreads();
43143 result = (arg1)->GetItemPosition(arg2);
43144
43145 wxPyEndAllowThreads(__tstate);
43146 if (PyErr_Occurred()) SWIG_fail;
43147 }
43148 {
43149 wxGBPosition * resultptr;
43150 resultptr = new wxGBPosition((wxGBPosition &)(result));
43151 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43152 }
43153 return resultobj;
43154 fail:
43155 return NULL;
43156 }
43157
43158
43159 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43160 PyObject *resultobj;
43161 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43162 size_t arg2 ;
43163 wxGBPosition result;
43164 PyObject * obj0 = 0 ;
43165 PyObject * obj1 = 0 ;
43166
43167 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43169 if (SWIG_arg_fail(1)) SWIG_fail;
43170 {
43171 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43172 if (SWIG_arg_fail(2)) SWIG_fail;
43173 }
43174 {
43175 PyThreadState* __tstate = wxPyBeginAllowThreads();
43176 result = (arg1)->GetItemPosition(arg2);
43177
43178 wxPyEndAllowThreads(__tstate);
43179 if (PyErr_Occurred()) SWIG_fail;
43180 }
43181 {
43182 wxGBPosition * resultptr;
43183 resultptr = new wxGBPosition((wxGBPosition &)(result));
43184 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43185 }
43186 return resultobj;
43187 fail:
43188 return NULL;
43189 }
43190
43191
43192 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43193 int argc;
43194 PyObject *argv[3];
43195 int ii;
43196
43197 argc = PyObject_Length(args);
43198 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43199 argv[ii] = PyTuple_GetItem(args,ii);
43200 }
43201 if (argc == 2) {
43202 int _v;
43203 {
43204 void *ptr;
43205 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43206 _v = 0;
43207 PyErr_Clear();
43208 } else {
43209 _v = 1;
43210 }
43211 }
43212 if (_v) {
43213 {
43214 void *ptr;
43215 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43216 _v = 0;
43217 PyErr_Clear();
43218 } else {
43219 _v = 1;
43220 }
43221 }
43222 if (_v) {
43223 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43224 }
43225 }
43226 }
43227 if (argc == 2) {
43228 int _v;
43229 {
43230 void *ptr;
43231 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43232 _v = 0;
43233 PyErr_Clear();
43234 } else {
43235 _v = 1;
43236 }
43237 }
43238 if (_v) {
43239 {
43240 void *ptr;
43241 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43242 _v = 0;
43243 PyErr_Clear();
43244 } else {
43245 _v = 1;
43246 }
43247 }
43248 if (_v) {
43249 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43250 }
43251 }
43252 }
43253 if (argc == 2) {
43254 int _v;
43255 {
43256 void *ptr;
43257 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43258 _v = 0;
43259 PyErr_Clear();
43260 } else {
43261 _v = 1;
43262 }
43263 }
43264 if (_v) {
43265 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43266 if (_v) {
43267 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43268 }
43269 }
43270 }
43271
43272 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43273 return NULL;
43274 }
43275
43276
43277 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43278 PyObject *resultobj;
43279 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43280 wxWindow *arg2 = (wxWindow *) 0 ;
43281 wxGBPosition *arg3 = 0 ;
43282 bool result;
43283 wxGBPosition temp3 ;
43284 PyObject * obj0 = 0 ;
43285 PyObject * obj1 = 0 ;
43286 PyObject * obj2 = 0 ;
43287
43288 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43290 if (SWIG_arg_fail(1)) SWIG_fail;
43291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43292 if (SWIG_arg_fail(2)) SWIG_fail;
43293 {
43294 arg3 = &temp3;
43295 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43296 }
43297 {
43298 PyThreadState* __tstate = wxPyBeginAllowThreads();
43299 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43300
43301 wxPyEndAllowThreads(__tstate);
43302 if (PyErr_Occurred()) SWIG_fail;
43303 }
43304 {
43305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43306 }
43307 return resultobj;
43308 fail:
43309 return NULL;
43310 }
43311
43312
43313 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43314 PyObject *resultobj;
43315 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43316 wxSizer *arg2 = (wxSizer *) 0 ;
43317 wxGBPosition *arg3 = 0 ;
43318 bool result;
43319 wxGBPosition temp3 ;
43320 PyObject * obj0 = 0 ;
43321 PyObject * obj1 = 0 ;
43322 PyObject * obj2 = 0 ;
43323
43324 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43326 if (SWIG_arg_fail(1)) SWIG_fail;
43327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43328 if (SWIG_arg_fail(2)) SWIG_fail;
43329 {
43330 arg3 = &temp3;
43331 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43332 }
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43336
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 {
43341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43350 PyObject *resultobj;
43351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43352 size_t arg2 ;
43353 wxGBPosition *arg3 = 0 ;
43354 bool result;
43355 wxGBPosition temp3 ;
43356 PyObject * obj0 = 0 ;
43357 PyObject * obj1 = 0 ;
43358 PyObject * obj2 = 0 ;
43359
43360 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43362 if (SWIG_arg_fail(1)) SWIG_fail;
43363 {
43364 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43365 if (SWIG_arg_fail(2)) SWIG_fail;
43366 }
43367 {
43368 arg3 = &temp3;
43369 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43370 }
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43374
43375 wxPyEndAllowThreads(__tstate);
43376 if (PyErr_Occurred()) SWIG_fail;
43377 }
43378 {
43379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43380 }
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43388 int argc;
43389 PyObject *argv[4];
43390 int ii;
43391
43392 argc = PyObject_Length(args);
43393 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43394 argv[ii] = PyTuple_GetItem(args,ii);
43395 }
43396 if (argc == 3) {
43397 int _v;
43398 {
43399 void *ptr;
43400 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43401 _v = 0;
43402 PyErr_Clear();
43403 } else {
43404 _v = 1;
43405 }
43406 }
43407 if (_v) {
43408 {
43409 void *ptr;
43410 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43411 _v = 0;
43412 PyErr_Clear();
43413 } else {
43414 _v = 1;
43415 }
43416 }
43417 if (_v) {
43418 {
43419 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43420 }
43421 if (_v) {
43422 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43423 }
43424 }
43425 }
43426 }
43427 if (argc == 3) {
43428 int _v;
43429 {
43430 void *ptr;
43431 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43432 _v = 0;
43433 PyErr_Clear();
43434 } else {
43435 _v = 1;
43436 }
43437 }
43438 if (_v) {
43439 {
43440 void *ptr;
43441 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43442 _v = 0;
43443 PyErr_Clear();
43444 } else {
43445 _v = 1;
43446 }
43447 }
43448 if (_v) {
43449 {
43450 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43451 }
43452 if (_v) {
43453 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43454 }
43455 }
43456 }
43457 }
43458 if (argc == 3) {
43459 int _v;
43460 {
43461 void *ptr;
43462 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43463 _v = 0;
43464 PyErr_Clear();
43465 } else {
43466 _v = 1;
43467 }
43468 }
43469 if (_v) {
43470 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43471 if (_v) {
43472 {
43473 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43474 }
43475 if (_v) {
43476 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43477 }
43478 }
43479 }
43480 }
43481
43482 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43483 return NULL;
43484 }
43485
43486
43487 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43488 PyObject *resultobj;
43489 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43490 wxWindow *arg2 = (wxWindow *) 0 ;
43491 wxGBSpan result;
43492 PyObject * obj0 = 0 ;
43493 PyObject * obj1 = 0 ;
43494
43495 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43497 if (SWIG_arg_fail(1)) SWIG_fail;
43498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43499 if (SWIG_arg_fail(2)) SWIG_fail;
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (arg1)->GetItemSpan(arg2);
43503
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 wxGBSpan * resultptr;
43509 resultptr = new wxGBSpan((wxGBSpan &)(result));
43510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43511 }
43512 return resultobj;
43513 fail:
43514 return NULL;
43515 }
43516
43517
43518 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43519 PyObject *resultobj;
43520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43521 wxSizer *arg2 = (wxSizer *) 0 ;
43522 wxGBSpan result;
43523 PyObject * obj0 = 0 ;
43524 PyObject * obj1 = 0 ;
43525
43526 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43528 if (SWIG_arg_fail(1)) SWIG_fail;
43529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43530 if (SWIG_arg_fail(2)) SWIG_fail;
43531 {
43532 PyThreadState* __tstate = wxPyBeginAllowThreads();
43533 result = (arg1)->GetItemSpan(arg2);
43534
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 {
43539 wxGBSpan * resultptr;
43540 resultptr = new wxGBSpan((wxGBSpan &)(result));
43541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43542 }
43543 return resultobj;
43544 fail:
43545 return NULL;
43546 }
43547
43548
43549 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43550 PyObject *resultobj;
43551 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43552 size_t arg2 ;
43553 wxGBSpan result;
43554 PyObject * obj0 = 0 ;
43555 PyObject * obj1 = 0 ;
43556
43557 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43559 if (SWIG_arg_fail(1)) SWIG_fail;
43560 {
43561 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43562 if (SWIG_arg_fail(2)) SWIG_fail;
43563 }
43564 {
43565 PyThreadState* __tstate = wxPyBeginAllowThreads();
43566 result = (arg1)->GetItemSpan(arg2);
43567
43568 wxPyEndAllowThreads(__tstate);
43569 if (PyErr_Occurred()) SWIG_fail;
43570 }
43571 {
43572 wxGBSpan * resultptr;
43573 resultptr = new wxGBSpan((wxGBSpan &)(result));
43574 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43575 }
43576 return resultobj;
43577 fail:
43578 return NULL;
43579 }
43580
43581
43582 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43583 int argc;
43584 PyObject *argv[3];
43585 int ii;
43586
43587 argc = PyObject_Length(args);
43588 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43589 argv[ii] = PyTuple_GetItem(args,ii);
43590 }
43591 if (argc == 2) {
43592 int _v;
43593 {
43594 void *ptr;
43595 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43596 _v = 0;
43597 PyErr_Clear();
43598 } else {
43599 _v = 1;
43600 }
43601 }
43602 if (_v) {
43603 {
43604 void *ptr;
43605 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43606 _v = 0;
43607 PyErr_Clear();
43608 } else {
43609 _v = 1;
43610 }
43611 }
43612 if (_v) {
43613 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43614 }
43615 }
43616 }
43617 if (argc == 2) {
43618 int _v;
43619 {
43620 void *ptr;
43621 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43622 _v = 0;
43623 PyErr_Clear();
43624 } else {
43625 _v = 1;
43626 }
43627 }
43628 if (_v) {
43629 {
43630 void *ptr;
43631 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43632 _v = 0;
43633 PyErr_Clear();
43634 } else {
43635 _v = 1;
43636 }
43637 }
43638 if (_v) {
43639 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43640 }
43641 }
43642 }
43643 if (argc == 2) {
43644 int _v;
43645 {
43646 void *ptr;
43647 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43648 _v = 0;
43649 PyErr_Clear();
43650 } else {
43651 _v = 1;
43652 }
43653 }
43654 if (_v) {
43655 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43656 if (_v) {
43657 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43658 }
43659 }
43660 }
43661
43662 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43663 return NULL;
43664 }
43665
43666
43667 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43668 PyObject *resultobj;
43669 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43670 wxWindow *arg2 = (wxWindow *) 0 ;
43671 wxGBSpan *arg3 = 0 ;
43672 bool result;
43673 wxGBSpan temp3 ;
43674 PyObject * obj0 = 0 ;
43675 PyObject * obj1 = 0 ;
43676 PyObject * obj2 = 0 ;
43677
43678 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43680 if (SWIG_arg_fail(1)) SWIG_fail;
43681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43682 if (SWIG_arg_fail(2)) SWIG_fail;
43683 {
43684 arg3 = &temp3;
43685 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43686 }
43687 {
43688 PyThreadState* __tstate = wxPyBeginAllowThreads();
43689 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43690
43691 wxPyEndAllowThreads(__tstate);
43692 if (PyErr_Occurred()) SWIG_fail;
43693 }
43694 {
43695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43696 }
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43704 PyObject *resultobj;
43705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43706 wxSizer *arg2 = (wxSizer *) 0 ;
43707 wxGBSpan *arg3 = 0 ;
43708 bool result;
43709 wxGBSpan temp3 ;
43710 PyObject * obj0 = 0 ;
43711 PyObject * obj1 = 0 ;
43712 PyObject * obj2 = 0 ;
43713
43714 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43716 if (SWIG_arg_fail(1)) SWIG_fail;
43717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43718 if (SWIG_arg_fail(2)) SWIG_fail;
43719 {
43720 arg3 = &temp3;
43721 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43722 }
43723 {
43724 PyThreadState* __tstate = wxPyBeginAllowThreads();
43725 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43726
43727 wxPyEndAllowThreads(__tstate);
43728 if (PyErr_Occurred()) SWIG_fail;
43729 }
43730 {
43731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43732 }
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43740 PyObject *resultobj;
43741 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43742 size_t arg2 ;
43743 wxGBSpan *arg3 = 0 ;
43744 bool result;
43745 wxGBSpan temp3 ;
43746 PyObject * obj0 = 0 ;
43747 PyObject * obj1 = 0 ;
43748 PyObject * obj2 = 0 ;
43749
43750 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43752 if (SWIG_arg_fail(1)) SWIG_fail;
43753 {
43754 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43755 if (SWIG_arg_fail(2)) SWIG_fail;
43756 }
43757 {
43758 arg3 = &temp3;
43759 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43760 }
43761 {
43762 PyThreadState* __tstate = wxPyBeginAllowThreads();
43763 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43764
43765 wxPyEndAllowThreads(__tstate);
43766 if (PyErr_Occurred()) SWIG_fail;
43767 }
43768 {
43769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43770 }
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43778 int argc;
43779 PyObject *argv[4];
43780 int ii;
43781
43782 argc = PyObject_Length(args);
43783 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43784 argv[ii] = PyTuple_GetItem(args,ii);
43785 }
43786 if (argc == 3) {
43787 int _v;
43788 {
43789 void *ptr;
43790 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43791 _v = 0;
43792 PyErr_Clear();
43793 } else {
43794 _v = 1;
43795 }
43796 }
43797 if (_v) {
43798 {
43799 void *ptr;
43800 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43801 _v = 0;
43802 PyErr_Clear();
43803 } else {
43804 _v = 1;
43805 }
43806 }
43807 if (_v) {
43808 {
43809 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43810 }
43811 if (_v) {
43812 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43813 }
43814 }
43815 }
43816 }
43817 if (argc == 3) {
43818 int _v;
43819 {
43820 void *ptr;
43821 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43822 _v = 0;
43823 PyErr_Clear();
43824 } else {
43825 _v = 1;
43826 }
43827 }
43828 if (_v) {
43829 {
43830 void *ptr;
43831 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43832 _v = 0;
43833 PyErr_Clear();
43834 } else {
43835 _v = 1;
43836 }
43837 }
43838 if (_v) {
43839 {
43840 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43841 }
43842 if (_v) {
43843 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43844 }
43845 }
43846 }
43847 }
43848 if (argc == 3) {
43849 int _v;
43850 {
43851 void *ptr;
43852 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43853 _v = 0;
43854 PyErr_Clear();
43855 } else {
43856 _v = 1;
43857 }
43858 }
43859 if (_v) {
43860 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43861 if (_v) {
43862 {
43863 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43864 }
43865 if (_v) {
43866 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43867 }
43868 }
43869 }
43870 }
43871
43872 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43873 return NULL;
43874 }
43875
43876
43877 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43878 PyObject *resultobj;
43879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43880 wxWindow *arg2 = (wxWindow *) 0 ;
43881 wxGBSizerItem *result;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884
43885 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43887 if (SWIG_arg_fail(1)) SWIG_fail;
43888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43889 if (SWIG_arg_fail(2)) SWIG_fail;
43890 {
43891 PyThreadState* __tstate = wxPyBeginAllowThreads();
43892 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43893
43894 wxPyEndAllowThreads(__tstate);
43895 if (PyErr_Occurred()) SWIG_fail;
43896 }
43897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43898 return resultobj;
43899 fail:
43900 return NULL;
43901 }
43902
43903
43904 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43905 PyObject *resultobj;
43906 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43907 wxSizer *arg2 = (wxSizer *) 0 ;
43908 wxGBSizerItem *result;
43909 PyObject * obj0 = 0 ;
43910 PyObject * obj1 = 0 ;
43911
43912 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43914 if (SWIG_arg_fail(1)) SWIG_fail;
43915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43916 if (SWIG_arg_fail(2)) SWIG_fail;
43917 {
43918 PyThreadState* __tstate = wxPyBeginAllowThreads();
43919 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43920
43921 wxPyEndAllowThreads(__tstate);
43922 if (PyErr_Occurred()) SWIG_fail;
43923 }
43924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43925 return resultobj;
43926 fail:
43927 return NULL;
43928 }
43929
43930
43931 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43932 int argc;
43933 PyObject *argv[3];
43934 int ii;
43935
43936 argc = PyObject_Length(args);
43937 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43938 argv[ii] = PyTuple_GetItem(args,ii);
43939 }
43940 if (argc == 2) {
43941 int _v;
43942 {
43943 void *ptr;
43944 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43945 _v = 0;
43946 PyErr_Clear();
43947 } else {
43948 _v = 1;
43949 }
43950 }
43951 if (_v) {
43952 {
43953 void *ptr;
43954 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43955 _v = 0;
43956 PyErr_Clear();
43957 } else {
43958 _v = 1;
43959 }
43960 }
43961 if (_v) {
43962 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43963 }
43964 }
43965 }
43966 if (argc == 2) {
43967 int _v;
43968 {
43969 void *ptr;
43970 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43971 _v = 0;
43972 PyErr_Clear();
43973 } else {
43974 _v = 1;
43975 }
43976 }
43977 if (_v) {
43978 {
43979 void *ptr;
43980 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43981 _v = 0;
43982 PyErr_Clear();
43983 } else {
43984 _v = 1;
43985 }
43986 }
43987 if (_v) {
43988 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43989 }
43990 }
43991 }
43992
43993 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43994 return NULL;
43995 }
43996
43997
43998 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43999 PyObject *resultobj;
44000 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44001 wxGBPosition *arg2 = 0 ;
44002 wxGBSizerItem *result;
44003 wxGBPosition temp2 ;
44004 PyObject * obj0 = 0 ;
44005 PyObject * obj1 = 0 ;
44006 char *kwnames[] = {
44007 (char *) "self",(char *) "pos", NULL
44008 };
44009
44010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44012 if (SWIG_arg_fail(1)) SWIG_fail;
44013 {
44014 arg2 = &temp2;
44015 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44016 }
44017 {
44018 PyThreadState* __tstate = wxPyBeginAllowThreads();
44019 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44020
44021 wxPyEndAllowThreads(__tstate);
44022 if (PyErr_Occurred()) SWIG_fail;
44023 }
44024 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44025 return resultobj;
44026 fail:
44027 return NULL;
44028 }
44029
44030
44031 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44032 PyObject *resultobj;
44033 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44034 wxPoint *arg2 = 0 ;
44035 wxGBSizerItem *result;
44036 wxPoint temp2 ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 char *kwnames[] = {
44040 (char *) "self",(char *) "pt", NULL
44041 };
44042
44043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44045 if (SWIG_arg_fail(1)) SWIG_fail;
44046 {
44047 arg2 = &temp2;
44048 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44049 }
44050 {
44051 PyThreadState* __tstate = wxPyBeginAllowThreads();
44052 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44053
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44058 return resultobj;
44059 fail:
44060 return NULL;
44061 }
44062
44063
44064 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44065 PyObject *resultobj;
44066 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44067 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44068 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44069 bool result;
44070 PyObject * obj0 = 0 ;
44071 PyObject * obj1 = 0 ;
44072 PyObject * obj2 = 0 ;
44073 char *kwnames[] = {
44074 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44075 };
44076
44077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44079 if (SWIG_arg_fail(1)) SWIG_fail;
44080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44081 if (SWIG_arg_fail(2)) SWIG_fail;
44082 if (obj2) {
44083 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44084 if (SWIG_arg_fail(3)) SWIG_fail;
44085 }
44086 {
44087 PyThreadState* __tstate = wxPyBeginAllowThreads();
44088 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44089
44090 wxPyEndAllowThreads(__tstate);
44091 if (PyErr_Occurred()) SWIG_fail;
44092 }
44093 {
44094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44095 }
44096 return resultobj;
44097 fail:
44098 return NULL;
44099 }
44100
44101
44102 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44103 PyObject *resultobj;
44104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44105 wxGBPosition *arg2 = 0 ;
44106 wxGBSpan *arg3 = 0 ;
44107 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44108 bool result;
44109 wxGBPosition temp2 ;
44110 wxGBSpan temp3 ;
44111 PyObject * obj0 = 0 ;
44112 PyObject * obj1 = 0 ;
44113 PyObject * obj2 = 0 ;
44114 PyObject * obj3 = 0 ;
44115 char *kwnames[] = {
44116 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44117 };
44118
44119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44121 if (SWIG_arg_fail(1)) SWIG_fail;
44122 {
44123 arg2 = &temp2;
44124 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44125 }
44126 {
44127 arg3 = &temp3;
44128 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44129 }
44130 if (obj3) {
44131 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44132 if (SWIG_arg_fail(4)) SWIG_fail;
44133 }
44134 {
44135 PyThreadState* __tstate = wxPyBeginAllowThreads();
44136 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44137
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44151 PyObject *obj;
44152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44153 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44154 Py_INCREF(obj);
44155 return Py_BuildValue((char *)"");
44156 }
44157 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44158 PyObject *resultobj;
44159 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44160 wxRelationship arg2 ;
44161 wxWindow *arg3 = (wxWindow *) 0 ;
44162 wxEdge arg4 ;
44163 int arg5 = (int) 0 ;
44164 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44165 PyObject * obj0 = 0 ;
44166 PyObject * obj1 = 0 ;
44167 PyObject * obj2 = 0 ;
44168 PyObject * obj3 = 0 ;
44169 PyObject * obj4 = 0 ;
44170 PyObject * obj5 = 0 ;
44171 char *kwnames[] = {
44172 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44173 };
44174
44175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44177 if (SWIG_arg_fail(1)) SWIG_fail;
44178 {
44179 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44180 if (SWIG_arg_fail(2)) SWIG_fail;
44181 }
44182 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44183 if (SWIG_arg_fail(3)) SWIG_fail;
44184 {
44185 arg4 = (wxEdge)(SWIG_As_int(obj3));
44186 if (SWIG_arg_fail(4)) SWIG_fail;
44187 }
44188 if (obj4) {
44189 {
44190 arg5 = (int)(SWIG_As_int(obj4));
44191 if (SWIG_arg_fail(5)) SWIG_fail;
44192 }
44193 }
44194 if (obj5) {
44195 {
44196 arg6 = (int)(SWIG_As_int(obj5));
44197 if (SWIG_arg_fail(6)) SWIG_fail;
44198 }
44199 }
44200 {
44201 PyThreadState* __tstate = wxPyBeginAllowThreads();
44202 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44203
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 Py_INCREF(Py_None); resultobj = Py_None;
44208 return resultobj;
44209 fail:
44210 return NULL;
44211 }
44212
44213
44214 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44215 PyObject *resultobj;
44216 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44217 wxWindow *arg2 = (wxWindow *) 0 ;
44218 int arg3 = (int) 0 ;
44219 PyObject * obj0 = 0 ;
44220 PyObject * obj1 = 0 ;
44221 PyObject * obj2 = 0 ;
44222 char *kwnames[] = {
44223 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44224 };
44225
44226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44228 if (SWIG_arg_fail(1)) SWIG_fail;
44229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44230 if (SWIG_arg_fail(2)) SWIG_fail;
44231 if (obj2) {
44232 {
44233 arg3 = (int)(SWIG_As_int(obj2));
44234 if (SWIG_arg_fail(3)) SWIG_fail;
44235 }
44236 }
44237 {
44238 PyThreadState* __tstate = wxPyBeginAllowThreads();
44239 (arg1)->LeftOf(arg2,arg3);
44240
44241 wxPyEndAllowThreads(__tstate);
44242 if (PyErr_Occurred()) SWIG_fail;
44243 }
44244 Py_INCREF(Py_None); resultobj = Py_None;
44245 return resultobj;
44246 fail:
44247 return NULL;
44248 }
44249
44250
44251 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44252 PyObject *resultobj;
44253 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44254 wxWindow *arg2 = (wxWindow *) 0 ;
44255 int arg3 = (int) 0 ;
44256 PyObject * obj0 = 0 ;
44257 PyObject * obj1 = 0 ;
44258 PyObject * obj2 = 0 ;
44259 char *kwnames[] = {
44260 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44261 };
44262
44263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44265 if (SWIG_arg_fail(1)) SWIG_fail;
44266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44267 if (SWIG_arg_fail(2)) SWIG_fail;
44268 if (obj2) {
44269 {
44270 arg3 = (int)(SWIG_As_int(obj2));
44271 if (SWIG_arg_fail(3)) SWIG_fail;
44272 }
44273 }
44274 {
44275 PyThreadState* __tstate = wxPyBeginAllowThreads();
44276 (arg1)->RightOf(arg2,arg3);
44277
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 Py_INCREF(Py_None); resultobj = Py_None;
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44289 PyObject *resultobj;
44290 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44291 wxWindow *arg2 = (wxWindow *) 0 ;
44292 int arg3 = (int) 0 ;
44293 PyObject * obj0 = 0 ;
44294 PyObject * obj1 = 0 ;
44295 PyObject * obj2 = 0 ;
44296 char *kwnames[] = {
44297 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44298 };
44299
44300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44302 if (SWIG_arg_fail(1)) SWIG_fail;
44303 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44304 if (SWIG_arg_fail(2)) SWIG_fail;
44305 if (obj2) {
44306 {
44307 arg3 = (int)(SWIG_As_int(obj2));
44308 if (SWIG_arg_fail(3)) SWIG_fail;
44309 }
44310 }
44311 {
44312 PyThreadState* __tstate = wxPyBeginAllowThreads();
44313 (arg1)->Above(arg2,arg3);
44314
44315 wxPyEndAllowThreads(__tstate);
44316 if (PyErr_Occurred()) SWIG_fail;
44317 }
44318 Py_INCREF(Py_None); resultobj = Py_None;
44319 return resultobj;
44320 fail:
44321 return NULL;
44322 }
44323
44324
44325 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44326 PyObject *resultobj;
44327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44328 wxWindow *arg2 = (wxWindow *) 0 ;
44329 int arg3 = (int) 0 ;
44330 PyObject * obj0 = 0 ;
44331 PyObject * obj1 = 0 ;
44332 PyObject * obj2 = 0 ;
44333 char *kwnames[] = {
44334 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44335 };
44336
44337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44339 if (SWIG_arg_fail(1)) SWIG_fail;
44340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44341 if (SWIG_arg_fail(2)) SWIG_fail;
44342 if (obj2) {
44343 {
44344 arg3 = (int)(SWIG_As_int(obj2));
44345 if (SWIG_arg_fail(3)) SWIG_fail;
44346 }
44347 }
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 (arg1)->Below(arg2,arg3);
44351
44352 wxPyEndAllowThreads(__tstate);
44353 if (PyErr_Occurred()) SWIG_fail;
44354 }
44355 Py_INCREF(Py_None); resultobj = Py_None;
44356 return resultobj;
44357 fail:
44358 return NULL;
44359 }
44360
44361
44362 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44363 PyObject *resultobj;
44364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44365 wxWindow *arg2 = (wxWindow *) 0 ;
44366 wxEdge arg3 ;
44367 int arg4 = (int) 0 ;
44368 PyObject * obj0 = 0 ;
44369 PyObject * obj1 = 0 ;
44370 PyObject * obj2 = 0 ;
44371 PyObject * obj3 = 0 ;
44372 char *kwnames[] = {
44373 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44374 };
44375
44376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44378 if (SWIG_arg_fail(1)) SWIG_fail;
44379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44380 if (SWIG_arg_fail(2)) SWIG_fail;
44381 {
44382 arg3 = (wxEdge)(SWIG_As_int(obj2));
44383 if (SWIG_arg_fail(3)) SWIG_fail;
44384 }
44385 if (obj3) {
44386 {
44387 arg4 = (int)(SWIG_As_int(obj3));
44388 if (SWIG_arg_fail(4)) SWIG_fail;
44389 }
44390 }
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44394
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 Py_INCREF(Py_None); resultobj = Py_None;
44399 return resultobj;
44400 fail:
44401 return NULL;
44402 }
44403
44404
44405 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44406 PyObject *resultobj;
44407 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44408 wxWindow *arg2 = (wxWindow *) 0 ;
44409 wxEdge arg3 ;
44410 int arg4 ;
44411 PyObject * obj0 = 0 ;
44412 PyObject * obj1 = 0 ;
44413 PyObject * obj2 = 0 ;
44414 PyObject * obj3 = 0 ;
44415 char *kwnames[] = {
44416 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44417 };
44418
44419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44421 if (SWIG_arg_fail(1)) SWIG_fail;
44422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44423 if (SWIG_arg_fail(2)) SWIG_fail;
44424 {
44425 arg3 = (wxEdge)(SWIG_As_int(obj2));
44426 if (SWIG_arg_fail(3)) SWIG_fail;
44427 }
44428 {
44429 arg4 = (int)(SWIG_As_int(obj3));
44430 if (SWIG_arg_fail(4)) SWIG_fail;
44431 }
44432 {
44433 PyThreadState* __tstate = wxPyBeginAllowThreads();
44434 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44435
44436 wxPyEndAllowThreads(__tstate);
44437 if (PyErr_Occurred()) SWIG_fail;
44438 }
44439 Py_INCREF(Py_None); resultobj = Py_None;
44440 return resultobj;
44441 fail:
44442 return NULL;
44443 }
44444
44445
44446 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44447 PyObject *resultobj;
44448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44449 int arg2 ;
44450 PyObject * obj0 = 0 ;
44451 PyObject * obj1 = 0 ;
44452 char *kwnames[] = {
44453 (char *) "self",(char *) "val", NULL
44454 };
44455
44456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44458 if (SWIG_arg_fail(1)) SWIG_fail;
44459 {
44460 arg2 = (int)(SWIG_As_int(obj1));
44461 if (SWIG_arg_fail(2)) SWIG_fail;
44462 }
44463 {
44464 PyThreadState* __tstate = wxPyBeginAllowThreads();
44465 (arg1)->Absolute(arg2);
44466
44467 wxPyEndAllowThreads(__tstate);
44468 if (PyErr_Occurred()) SWIG_fail;
44469 }
44470 Py_INCREF(Py_None); resultobj = Py_None;
44471 return resultobj;
44472 fail:
44473 return NULL;
44474 }
44475
44476
44477 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44478 PyObject *resultobj;
44479 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44480 PyObject * obj0 = 0 ;
44481 char *kwnames[] = {
44482 (char *) "self", NULL
44483 };
44484
44485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44487 if (SWIG_arg_fail(1)) SWIG_fail;
44488 {
44489 PyThreadState* __tstate = wxPyBeginAllowThreads();
44490 (arg1)->Unconstrained();
44491
44492 wxPyEndAllowThreads(__tstate);
44493 if (PyErr_Occurred()) SWIG_fail;
44494 }
44495 Py_INCREF(Py_None); resultobj = Py_None;
44496 return resultobj;
44497 fail:
44498 return NULL;
44499 }
44500
44501
44502 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44503 PyObject *resultobj;
44504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44505 PyObject * obj0 = 0 ;
44506 char *kwnames[] = {
44507 (char *) "self", NULL
44508 };
44509
44510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44512 if (SWIG_arg_fail(1)) SWIG_fail;
44513 {
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 (arg1)->AsIs();
44516
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 Py_INCREF(Py_None); resultobj = Py_None;
44521 return resultobj;
44522 fail:
44523 return NULL;
44524 }
44525
44526
44527 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44528 PyObject *resultobj;
44529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44530 wxWindow *result;
44531 PyObject * obj0 = 0 ;
44532 char *kwnames[] = {
44533 (char *) "self", NULL
44534 };
44535
44536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44538 if (SWIG_arg_fail(1)) SWIG_fail;
44539 {
44540 PyThreadState* __tstate = wxPyBeginAllowThreads();
44541 result = (wxWindow *)(arg1)->GetOtherWindow();
44542
44543 wxPyEndAllowThreads(__tstate);
44544 if (PyErr_Occurred()) SWIG_fail;
44545 }
44546 {
44547 resultobj = wxPyMake_wxObject(result, 0);
44548 }
44549 return resultobj;
44550 fail:
44551 return NULL;
44552 }
44553
44554
44555 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44556 PyObject *resultobj;
44557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44558 wxEdge result;
44559 PyObject * obj0 = 0 ;
44560 char *kwnames[] = {
44561 (char *) "self", NULL
44562 };
44563
44564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44566 if (SWIG_arg_fail(1)) SWIG_fail;
44567 {
44568 PyThreadState* __tstate = wxPyBeginAllowThreads();
44569 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44570
44571 wxPyEndAllowThreads(__tstate);
44572 if (PyErr_Occurred()) SWIG_fail;
44573 }
44574 resultobj = SWIG_From_int((result));
44575 return resultobj;
44576 fail:
44577 return NULL;
44578 }
44579
44580
44581 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44582 PyObject *resultobj;
44583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44584 wxEdge arg2 ;
44585 PyObject * obj0 = 0 ;
44586 PyObject * obj1 = 0 ;
44587 char *kwnames[] = {
44588 (char *) "self",(char *) "which", NULL
44589 };
44590
44591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44593 if (SWIG_arg_fail(1)) SWIG_fail;
44594 {
44595 arg2 = (wxEdge)(SWIG_As_int(obj1));
44596 if (SWIG_arg_fail(2)) SWIG_fail;
44597 }
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 (arg1)->SetEdge((wxEdge )arg2);
44601
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 Py_INCREF(Py_None); resultobj = Py_None;
44606 return resultobj;
44607 fail:
44608 return NULL;
44609 }
44610
44611
44612 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44613 PyObject *resultobj;
44614 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44615 int arg2 ;
44616 PyObject * obj0 = 0 ;
44617 PyObject * obj1 = 0 ;
44618 char *kwnames[] = {
44619 (char *) "self",(char *) "v", NULL
44620 };
44621
44622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44624 if (SWIG_arg_fail(1)) SWIG_fail;
44625 {
44626 arg2 = (int)(SWIG_As_int(obj1));
44627 if (SWIG_arg_fail(2)) SWIG_fail;
44628 }
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 (arg1)->SetValue(arg2);
44632
44633 wxPyEndAllowThreads(__tstate);
44634 if (PyErr_Occurred()) SWIG_fail;
44635 }
44636 Py_INCREF(Py_None); resultobj = Py_None;
44637 return resultobj;
44638 fail:
44639 return NULL;
44640 }
44641
44642
44643 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44644 PyObject *resultobj;
44645 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44646 int result;
44647 PyObject * obj0 = 0 ;
44648 char *kwnames[] = {
44649 (char *) "self", NULL
44650 };
44651
44652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44654 if (SWIG_arg_fail(1)) SWIG_fail;
44655 {
44656 PyThreadState* __tstate = wxPyBeginAllowThreads();
44657 result = (int)(arg1)->GetMargin();
44658
44659 wxPyEndAllowThreads(__tstate);
44660 if (PyErr_Occurred()) SWIG_fail;
44661 }
44662 {
44663 resultobj = SWIG_From_int((int)(result));
44664 }
44665 return resultobj;
44666 fail:
44667 return NULL;
44668 }
44669
44670
44671 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44672 PyObject *resultobj;
44673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44674 int arg2 ;
44675 PyObject * obj0 = 0 ;
44676 PyObject * obj1 = 0 ;
44677 char *kwnames[] = {
44678 (char *) "self",(char *) "m", NULL
44679 };
44680
44681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44683 if (SWIG_arg_fail(1)) SWIG_fail;
44684 {
44685 arg2 = (int)(SWIG_As_int(obj1));
44686 if (SWIG_arg_fail(2)) SWIG_fail;
44687 }
44688 {
44689 PyThreadState* __tstate = wxPyBeginAllowThreads();
44690 (arg1)->SetMargin(arg2);
44691
44692 wxPyEndAllowThreads(__tstate);
44693 if (PyErr_Occurred()) SWIG_fail;
44694 }
44695 Py_INCREF(Py_None); resultobj = Py_None;
44696 return resultobj;
44697 fail:
44698 return NULL;
44699 }
44700
44701
44702 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44703 PyObject *resultobj;
44704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44705 int result;
44706 PyObject * obj0 = 0 ;
44707 char *kwnames[] = {
44708 (char *) "self", NULL
44709 };
44710
44711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44713 if (SWIG_arg_fail(1)) SWIG_fail;
44714 {
44715 PyThreadState* __tstate = wxPyBeginAllowThreads();
44716 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44717
44718 wxPyEndAllowThreads(__tstate);
44719 if (PyErr_Occurred()) SWIG_fail;
44720 }
44721 {
44722 resultobj = SWIG_From_int((int)(result));
44723 }
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44731 PyObject *resultobj;
44732 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44733 int result;
44734 PyObject * obj0 = 0 ;
44735 char *kwnames[] = {
44736 (char *) "self", NULL
44737 };
44738
44739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44741 if (SWIG_arg_fail(1)) SWIG_fail;
44742 {
44743 PyThreadState* __tstate = wxPyBeginAllowThreads();
44744 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44745
44746 wxPyEndAllowThreads(__tstate);
44747 if (PyErr_Occurred()) SWIG_fail;
44748 }
44749 {
44750 resultobj = SWIG_From_int((int)(result));
44751 }
44752 return resultobj;
44753 fail:
44754 return NULL;
44755 }
44756
44757
44758 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44759 PyObject *resultobj;
44760 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44761 int result;
44762 PyObject * obj0 = 0 ;
44763 char *kwnames[] = {
44764 (char *) "self", NULL
44765 };
44766
44767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44769 if (SWIG_arg_fail(1)) SWIG_fail;
44770 {
44771 PyThreadState* __tstate = wxPyBeginAllowThreads();
44772 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44773
44774 wxPyEndAllowThreads(__tstate);
44775 if (PyErr_Occurred()) SWIG_fail;
44776 }
44777 {
44778 resultobj = SWIG_From_int((int)(result));
44779 }
44780 return resultobj;
44781 fail:
44782 return NULL;
44783 }
44784
44785
44786 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44787 PyObject *resultobj;
44788 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44789 bool result;
44790 PyObject * obj0 = 0 ;
44791 char *kwnames[] = {
44792 (char *) "self", NULL
44793 };
44794
44795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44797 if (SWIG_arg_fail(1)) SWIG_fail;
44798 {
44799 PyThreadState* __tstate = wxPyBeginAllowThreads();
44800 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44801
44802 wxPyEndAllowThreads(__tstate);
44803 if (PyErr_Occurred()) SWIG_fail;
44804 }
44805 {
44806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44807 }
44808 return resultobj;
44809 fail:
44810 return NULL;
44811 }
44812
44813
44814 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44815 PyObject *resultobj;
44816 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44817 bool arg2 ;
44818 PyObject * obj0 = 0 ;
44819 PyObject * obj1 = 0 ;
44820 char *kwnames[] = {
44821 (char *) "self",(char *) "d", NULL
44822 };
44823
44824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44826 if (SWIG_arg_fail(1)) SWIG_fail;
44827 {
44828 arg2 = (bool)(SWIG_As_bool(obj1));
44829 if (SWIG_arg_fail(2)) SWIG_fail;
44830 }
44831 {
44832 PyThreadState* __tstate = wxPyBeginAllowThreads();
44833 (arg1)->SetDone(arg2);
44834
44835 wxPyEndAllowThreads(__tstate);
44836 if (PyErr_Occurred()) SWIG_fail;
44837 }
44838 Py_INCREF(Py_None); resultobj = Py_None;
44839 return resultobj;
44840 fail:
44841 return NULL;
44842 }
44843
44844
44845 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44846 PyObject *resultobj;
44847 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44848 wxRelationship result;
44849 PyObject * obj0 = 0 ;
44850 char *kwnames[] = {
44851 (char *) "self", NULL
44852 };
44853
44854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44856 if (SWIG_arg_fail(1)) SWIG_fail;
44857 {
44858 PyThreadState* __tstate = wxPyBeginAllowThreads();
44859 result = (wxRelationship)(arg1)->GetRelationship();
44860
44861 wxPyEndAllowThreads(__tstate);
44862 if (PyErr_Occurred()) SWIG_fail;
44863 }
44864 resultobj = SWIG_From_int((result));
44865 return resultobj;
44866 fail:
44867 return NULL;
44868 }
44869
44870
44871 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44872 PyObject *resultobj;
44873 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44874 wxRelationship arg2 ;
44875 PyObject * obj0 = 0 ;
44876 PyObject * obj1 = 0 ;
44877 char *kwnames[] = {
44878 (char *) "self",(char *) "r", NULL
44879 };
44880
44881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44883 if (SWIG_arg_fail(1)) SWIG_fail;
44884 {
44885 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44886 if (SWIG_arg_fail(2)) SWIG_fail;
44887 }
44888 {
44889 PyThreadState* __tstate = wxPyBeginAllowThreads();
44890 (arg1)->SetRelationship((wxRelationship )arg2);
44891
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 Py_INCREF(Py_None); resultobj = Py_None;
44896 return resultobj;
44897 fail:
44898 return NULL;
44899 }
44900
44901
44902 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44903 PyObject *resultobj;
44904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44905 wxWindow *arg2 = (wxWindow *) 0 ;
44906 bool result;
44907 PyObject * obj0 = 0 ;
44908 PyObject * obj1 = 0 ;
44909 char *kwnames[] = {
44910 (char *) "self",(char *) "otherW", NULL
44911 };
44912
44913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44915 if (SWIG_arg_fail(1)) SWIG_fail;
44916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44917 if (SWIG_arg_fail(2)) SWIG_fail;
44918 {
44919 PyThreadState* __tstate = wxPyBeginAllowThreads();
44920 result = (bool)(arg1)->ResetIfWin(arg2);
44921
44922 wxPyEndAllowThreads(__tstate);
44923 if (PyErr_Occurred()) SWIG_fail;
44924 }
44925 {
44926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44927 }
44928 return resultobj;
44929 fail:
44930 return NULL;
44931 }
44932
44933
44934 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44935 PyObject *resultobj;
44936 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44937 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44938 wxWindow *arg3 = (wxWindow *) 0 ;
44939 bool result;
44940 PyObject * obj0 = 0 ;
44941 PyObject * obj1 = 0 ;
44942 PyObject * obj2 = 0 ;
44943 char *kwnames[] = {
44944 (char *) "self",(char *) "constraints",(char *) "win", NULL
44945 };
44946
44947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44949 if (SWIG_arg_fail(1)) SWIG_fail;
44950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44951 if (SWIG_arg_fail(2)) SWIG_fail;
44952 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44953 if (SWIG_arg_fail(3)) SWIG_fail;
44954 {
44955 PyThreadState* __tstate = wxPyBeginAllowThreads();
44956 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44957
44958 wxPyEndAllowThreads(__tstate);
44959 if (PyErr_Occurred()) SWIG_fail;
44960 }
44961 {
44962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44963 }
44964 return resultobj;
44965 fail:
44966 return NULL;
44967 }
44968
44969
44970 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44971 PyObject *resultobj;
44972 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44973 wxEdge arg2 ;
44974 wxWindow *arg3 = (wxWindow *) 0 ;
44975 wxWindow *arg4 = (wxWindow *) 0 ;
44976 int result;
44977 PyObject * obj0 = 0 ;
44978 PyObject * obj1 = 0 ;
44979 PyObject * obj2 = 0 ;
44980 PyObject * obj3 = 0 ;
44981 char *kwnames[] = {
44982 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44983 };
44984
44985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44987 if (SWIG_arg_fail(1)) SWIG_fail;
44988 {
44989 arg2 = (wxEdge)(SWIG_As_int(obj1));
44990 if (SWIG_arg_fail(2)) SWIG_fail;
44991 }
44992 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44993 if (SWIG_arg_fail(3)) SWIG_fail;
44994 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44995 if (SWIG_arg_fail(4)) SWIG_fail;
44996 {
44997 PyThreadState* __tstate = wxPyBeginAllowThreads();
44998 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44999
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 {
45004 resultobj = SWIG_From_int((int)(result));
45005 }
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45013 PyObject *obj;
45014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45015 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45016 Py_INCREF(obj);
45017 return Py_BuildValue((char *)"");
45018 }
45019 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45020 PyObject *resultobj;
45021 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45022 wxIndividualLayoutConstraint *result;
45023 PyObject * obj0 = 0 ;
45024 char *kwnames[] = {
45025 (char *) "self", NULL
45026 };
45027
45028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45030 if (SWIG_arg_fail(1)) SWIG_fail;
45031 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45032
45033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45034 return resultobj;
45035 fail:
45036 return NULL;
45037 }
45038
45039
45040 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45041 PyObject *resultobj;
45042 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45043 wxIndividualLayoutConstraint *result;
45044 PyObject * obj0 = 0 ;
45045 char *kwnames[] = {
45046 (char *) "self", NULL
45047 };
45048
45049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45051 if (SWIG_arg_fail(1)) SWIG_fail;
45052 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45053
45054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45055 return resultobj;
45056 fail:
45057 return NULL;
45058 }
45059
45060
45061 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45062 PyObject *resultobj;
45063 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45064 wxIndividualLayoutConstraint *result;
45065 PyObject * obj0 = 0 ;
45066 char *kwnames[] = {
45067 (char *) "self", NULL
45068 };
45069
45070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45072 if (SWIG_arg_fail(1)) SWIG_fail;
45073 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45074
45075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45076 return resultobj;
45077 fail:
45078 return NULL;
45079 }
45080
45081
45082 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45083 PyObject *resultobj;
45084 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45085 wxIndividualLayoutConstraint *result;
45086 PyObject * obj0 = 0 ;
45087 char *kwnames[] = {
45088 (char *) "self", NULL
45089 };
45090
45091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45093 if (SWIG_arg_fail(1)) SWIG_fail;
45094 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45095
45096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj;
45105 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45106 wxIndividualLayoutConstraint *result;
45107 PyObject * obj0 = 0 ;
45108 char *kwnames[] = {
45109 (char *) "self", NULL
45110 };
45111
45112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45114 if (SWIG_arg_fail(1)) SWIG_fail;
45115 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45116
45117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45118 return resultobj;
45119 fail:
45120 return NULL;
45121 }
45122
45123
45124 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45125 PyObject *resultobj;
45126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45127 wxIndividualLayoutConstraint *result;
45128 PyObject * obj0 = 0 ;
45129 char *kwnames[] = {
45130 (char *) "self", NULL
45131 };
45132
45133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45135 if (SWIG_arg_fail(1)) SWIG_fail;
45136 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45137
45138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45146 PyObject *resultobj;
45147 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45148 wxIndividualLayoutConstraint *result;
45149 PyObject * obj0 = 0 ;
45150 char *kwnames[] = {
45151 (char *) "self", NULL
45152 };
45153
45154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45156 if (SWIG_arg_fail(1)) SWIG_fail;
45157 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45158
45159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45160 return resultobj;
45161 fail:
45162 return NULL;
45163 }
45164
45165
45166 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45167 PyObject *resultobj;
45168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45169 wxIndividualLayoutConstraint *result;
45170 PyObject * obj0 = 0 ;
45171 char *kwnames[] = {
45172 (char *) "self", NULL
45173 };
45174
45175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45177 if (SWIG_arg_fail(1)) SWIG_fail;
45178 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45179
45180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45181 return resultobj;
45182 fail:
45183 return NULL;
45184 }
45185
45186
45187 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45188 PyObject *resultobj;
45189 wxLayoutConstraints *result;
45190 char *kwnames[] = {
45191 NULL
45192 };
45193
45194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45195 {
45196 PyThreadState* __tstate = wxPyBeginAllowThreads();
45197 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45198
45199 wxPyEndAllowThreads(__tstate);
45200 if (PyErr_Occurred()) SWIG_fail;
45201 }
45202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45203 return resultobj;
45204 fail:
45205 return NULL;
45206 }
45207
45208
45209 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45210 PyObject *resultobj;
45211 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45212 wxWindow *arg2 = (wxWindow *) 0 ;
45213 int *arg3 = (int *) 0 ;
45214 bool result;
45215 int temp3 ;
45216 int res3 = 0 ;
45217 PyObject * obj0 = 0 ;
45218 PyObject * obj1 = 0 ;
45219 char *kwnames[] = {
45220 (char *) "self",(char *) "win", NULL
45221 };
45222
45223 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45226 if (SWIG_arg_fail(1)) SWIG_fail;
45227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45228 if (SWIG_arg_fail(2)) SWIG_fail;
45229 {
45230 PyThreadState* __tstate = wxPyBeginAllowThreads();
45231 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45232
45233 wxPyEndAllowThreads(__tstate);
45234 if (PyErr_Occurred()) SWIG_fail;
45235 }
45236 {
45237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45238 }
45239 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45240 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45241 return resultobj;
45242 fail:
45243 return NULL;
45244 }
45245
45246
45247 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45248 PyObject *resultobj;
45249 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45250 bool result;
45251 PyObject * obj0 = 0 ;
45252 char *kwnames[] = {
45253 (char *) "self", NULL
45254 };
45255
45256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45258 if (SWIG_arg_fail(1)) SWIG_fail;
45259 {
45260 PyThreadState* __tstate = wxPyBeginAllowThreads();
45261 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45262
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 {
45267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45268 }
45269 return resultobj;
45270 fail:
45271 return NULL;
45272 }
45273
45274
45275 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45276 PyObject *obj;
45277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45278 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45279 Py_INCREF(obj);
45280 return Py_BuildValue((char *)"");
45281 }
45282 static PyMethodDef SwigMethods[] = {
45283 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45284 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45285 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45288 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45309 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45322 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45337 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45391 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45419 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45438 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45440 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45448 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45449 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45461 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45473 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45477 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45483 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45493 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45503 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45510 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45590 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45592 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45594 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45596 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45598 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45600 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45602 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45604 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45606 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45608 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45610 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45612 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45614 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45628 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45646 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45649 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45669 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45675 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45681 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45744 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45751 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45787 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45797 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45803 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45805 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45807 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45810 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45814 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45817 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45820 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45822 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45827 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45835 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45839 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45842 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45844 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45848 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45865 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45870 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45872 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45876 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45880 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45891 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45894 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45897 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45901 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45908 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45913 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45918 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45967 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45987 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45994 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45998 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46008 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46180 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46220 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46235 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46238 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46293 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46320 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46364 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46372 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46391 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46392 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46429 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46459 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46462 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46466 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46469 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46479 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46491 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46503 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46513 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46523 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46537 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46544 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46545 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46546 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46547 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46548 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46553 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46580 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46592 { NULL, NULL, 0, NULL }
46593 };
46594
46595
46596 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46597
46598 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46599 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46600 }
46601 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46602 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46603 }
46604 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46605 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46606 }
46607 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46608 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46609 }
46610 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46611 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46612 }
46613 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46614 return (void *)((wxSizer *) ((wxGridSizer *) x));
46615 }
46616 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46617 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46618 }
46619 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46620 return (void *)((wxSizer *) ((wxPySizer *) x));
46621 }
46622 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46623 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46624 }
46625 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46626 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46627 }
46628 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46629 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46630 }
46631 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46632 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46633 }
46634 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46635 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46636 }
46637 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46638 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46639 }
46640 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46641 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46642 }
46643 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46644 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46645 }
46646 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46647 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46648 }
46649 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46650 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46651 }
46652 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46653 return (void *)((wxEvent *) ((wxPyEvent *) x));
46654 }
46655 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46656 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46657 }
46658 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46659 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46660 }
46661 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46663 }
46664 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46665 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46666 }
46667 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46668 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46669 }
46670 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46671 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46672 }
46673 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46674 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46675 }
46676 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46677 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46678 }
46679 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46680 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46681 }
46682 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46683 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46684 }
46685 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46686 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46687 }
46688 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46689 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46690 }
46691 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46692 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46693 }
46694 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46696 }
46697 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46699 }
46700 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46702 }
46703 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46705 }
46706 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46708 }
46709 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46711 }
46712 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46714 }
46715 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) ((wxShowEvent *) x));
46717 }
46718 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46720 }
46721 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46723 }
46724 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46726 }
46727 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46729 }
46730 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46732 }
46733 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46735 }
46736 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46737 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46738 }
46739 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46740 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46741 }
46742 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46743 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46744 }
46745 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46746 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46747 }
46748 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46749 return (void *)((wxControl *) ((wxControlWithItems *) x));
46750 }
46751 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46752 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46753 }
46754 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46755 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46756 }
46757 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46758 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46759 }
46760 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46761 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46762 }
46763 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46764 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46765 }
46766 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46767 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46768 }
46769 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46770 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46771 }
46772 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46773 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46774 }
46775 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46776 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46777 }
46778 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46779 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46780 }
46781 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46782 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46783 }
46784 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46785 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46786 }
46787 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46788 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46789 }
46790 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46791 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46792 }
46793 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46794 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46795 }
46796 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46797 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46798 }
46799 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46800 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46801 }
46802 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46803 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46804 }
46805 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46806 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46807 }
46808 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46809 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46810 }
46811 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46812 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46813 }
46814 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46815 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46816 }
46817 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46818 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46819 }
46820 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46821 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46822 }
46823 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46824 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46825 }
46826 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46827 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46828 }
46829 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46830 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46831 }
46832 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46833 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46834 }
46835 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46836 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46837 }
46838 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46839 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46840 }
46841 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46842 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46843 }
46844 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46845 return (void *)((wxObject *) ((wxSizerItem *) x));
46846 }
46847 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46848 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46849 }
46850 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46851 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46852 }
46853 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46854 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46855 }
46856 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46857 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46858 }
46859 static void *_p_wxSizerTo_p_wxObject(void *x) {
46860 return (void *)((wxObject *) ((wxSizer *) x));
46861 }
46862 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46863 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46864 }
46865 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46866 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46867 }
46868 static void *_p_wxEventTo_p_wxObject(void *x) {
46869 return (void *)((wxObject *) ((wxEvent *) x));
46870 }
46871 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46872 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46873 }
46874 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46875 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46876 }
46877 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46878 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46879 }
46880 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46881 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46882 }
46883 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46884 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46885 }
46886 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46887 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46888 }
46889 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46890 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46891 }
46892 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46893 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46894 }
46895 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46896 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46897 }
46898 static void *_p_wxControlTo_p_wxObject(void *x) {
46899 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46900 }
46901 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46902 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46903 }
46904 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) ((wxFSFile *) x));
46906 }
46907 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46909 }
46910 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46912 }
46913 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46915 }
46916 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46918 }
46919 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) ((wxMenuItem *) x));
46921 }
46922 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46924 }
46925 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46927 }
46928 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46930 }
46931 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46933 }
46934 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46936 }
46937 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46939 }
46940 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46942 }
46943 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46945 }
46946 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46948 }
46949 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46951 }
46952 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46954 }
46955 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46957 }
46958 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46960 }
46961 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46963 }
46964 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46966 }
46967 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46969 }
46970 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46972 }
46973 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46975 }
46976 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46978 }
46979 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) ((wxImageHandler *) x));
46981 }
46982 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46984 }
46985 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) ((wxEvtHandler *) x));
46987 }
46988 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46990 }
46991 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46993 }
46994 static void *_p_wxImageTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) ((wxImage *) x));
46996 }
46997 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46999 }
47000 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47002 }
47003 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47005 }
47006 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47008 }
47009 static void *_p_wxWindowTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47011 }
47012 static void *_p_wxMenuTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47014 }
47015 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47017 }
47018 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) ((wxFileSystem *) x));
47020 }
47021 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47023 }
47024 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47026 }
47027 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47029 }
47030 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47032 }
47033 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47035 }
47036 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47038 }
47039 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47041 }
47042 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47044 }
47045 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47047 }
47048 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47050 }
47051 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47053 }
47054 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47056 }
47057 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47059 }
47060 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47062 }
47063 static void *_p_wxControlTo_p_wxWindow(void *x) {
47064 return (void *)((wxWindow *) ((wxControl *) x));
47065 }
47066 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47067 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47068 }
47069 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47070 return (void *)((wxWindow *) ((wxMenuBar *) x));
47071 }
47072 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47073 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47074 }
47075 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47076 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47077 }
47078 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47079 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47080 }
47081 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47082 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47083 }
47084 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47085 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47086 }
47087 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47088 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47089 }
47090 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47091 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47092 }
47093 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47094 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47095 }
47096 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47097 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47098 }
47099 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47100 return (void *)((wxValidator *) ((wxPyValidator *) x));
47101 }
47102 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}};
47103 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}};
47104 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}};
47105 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}};
47106 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}};
47107 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}};
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230
47231 static swig_type_info *swig_types_initial[] = {
47232 _swigt__p_wxLayoutConstraints,
47233 _swigt__p_wxRealPoint,
47234 _swigt__p_wxSizerItem,
47235 _swigt__p_wxGBSizerItem,
47236 _swigt__p_wxScrollEvent,
47237 _swigt__p_wxEventLoop,
47238 _swigt__p_wxIndividualLayoutConstraint,
47239 _swigt__p_wxSizer,
47240 _swigt__p_wxBoxSizer,
47241 _swigt__p_wxStaticBoxSizer,
47242 _swigt__p_wxGridBagSizer,
47243 _swigt__p_wxAcceleratorEntry,
47244 _swigt__p_wxUpdateUIEvent,
47245 _swigt__p_wxEvent,
47246 _swigt__p_buffer,
47247 _swigt__p_wxMenu,
47248 _swigt__p_wxGridSizer,
47249 _swigt__p_wxFlexGridSizer,
47250 _swigt__p_wxInitDialogEvent,
47251 _swigt__p_wxItemContainer,
47252 _swigt__p_wxNcPaintEvent,
47253 _swigt__p_wxPaintEvent,
47254 _swigt__p_wxSysColourChangedEvent,
47255 _swigt__p_wxMouseCaptureChangedEvent,
47256 _swigt__p_wxDisplayChangedEvent,
47257 _swigt__p_wxPaletteChangedEvent,
47258 _swigt__p_wxControl,
47259 _swigt__p_wxFont,
47260 _swigt__p_wxMenuBarBase,
47261 _swigt__p_wxSetCursorEvent,
47262 _swigt__p_wxFSFile,
47263 _swigt__p_wxCaret,
47264 _swigt__ptrdiff_t,
47265 _swigt__std__ptrdiff_t,
47266 _swigt__p_wxRegion,
47267 _swigt__p_wxPoint2D,
47268 _swigt__p_int,
47269 _swigt__p_wxSize,
47270 _swigt__p_wxDC,
47271 _swigt__p_wxPySizer,
47272 _swigt__p_wxVisualAttributes,
47273 _swigt__p_wxNotifyEvent,
47274 _swigt__p_wxPyEvent,
47275 _swigt__p_wxPropagationDisabler,
47276 _swigt__p_form_ops_t,
47277 _swigt__p_wxAppTraits,
47278 _swigt__p_wxArrayString,
47279 _swigt__p_wxShowEvent,
47280 _swigt__p_wxToolTip,
47281 _swigt__p_wxMoveEvent,
47282 _swigt__p_wxSizeEvent,
47283 _swigt__p_wxActivateEvent,
47284 _swigt__p_wxIconizeEvent,
47285 _swigt__p_wxMaximizeEvent,
47286 _swigt__p_wxQueryNewPaletteEvent,
47287 _swigt__p_wxWindowCreateEvent,
47288 _swigt__p_wxIdleEvent,
47289 _swigt__p_wxDateEvent,
47290 _swigt__p_wxMenuItem,
47291 _swigt__p_wxStaticBox,
47292 _swigt__p_long,
47293 _swigt__p_wxDuplexMode,
47294 _swigt__p_wxTIFFHandler,
47295 _swigt__p_wxXPMHandler,
47296 _swigt__p_wxPNMHandler,
47297 _swigt__p_wxJPEGHandler,
47298 _swigt__p_wxPCXHandler,
47299 _swigt__p_wxGIFHandler,
47300 _swigt__p_wxPNGHandler,
47301 _swigt__p_wxANIHandler,
47302 _swigt__p_wxMemoryFSHandler,
47303 _swigt__p_wxZipFSHandler,
47304 _swigt__p_wxInternetFSHandler,
47305 _swigt__p_wxPyFileSystemHandler,
47306 _swigt__p_wxEvtHandler,
47307 _swigt__p_wxCURHandler,
47308 _swigt__p_wxICOHandler,
47309 _swigt__p_wxBMPHandler,
47310 _swigt__p_wxImageHandler,
47311 _swigt__p_wxFileSystemHandler,
47312 _swigt__p_wxRect,
47313 _swigt__p_wxButton,
47314 _swigt__p_wxGBSpan,
47315 _swigt__p_wxPropagateOnce,
47316 _swigt__p_wxAcceleratorTable,
47317 _swigt__p_wxStdDialogButtonSizer,
47318 _swigt__p_char,
47319 _swigt__p_wxGBPosition,
47320 _swigt__p_wxImage,
47321 _swigt__p_wxFrame,
47322 _swigt__p_wxScrollWinEvent,
47323 _swigt__p_wxPaperSize,
47324 _swigt__p_wxImageHistogram,
47325 _swigt__p_wxPoint,
47326 _swigt__p_wxCursor,
47327 _swigt__p_wxObject,
47328 _swigt__p_wxInputStream,
47329 _swigt__p_wxOutputStream,
47330 _swigt__p_wxPyInputStream,
47331 _swigt__p_wxDateTime,
47332 _swigt__p_wxKeyEvent,
47333 _swigt__p_wxNavigationKeyEvent,
47334 _swigt__p_wxWindowDestroyEvent,
47335 _swigt__p_unsigned_long,
47336 _swigt__p_wxWindow,
47337 _swigt__p_wxMenuBar,
47338 _swigt__p_wxFileSystem,
47339 _swigt__p_wxBitmap,
47340 _swigt__unsigned_int,
47341 _swigt__p_unsigned_int,
47342 _swigt__p_wxMenuEvent,
47343 _swigt__p_wxContextMenuEvent,
47344 _swigt__p_unsigned_char,
47345 _swigt__p_wxEraseEvent,
47346 _swigt__p_wxMouseEvent,
47347 _swigt__p_wxCloseEvent,
47348 _swigt__p_wxPyApp,
47349 _swigt__p_wxCommandEvent,
47350 _swigt__p_wxPyCommandEvent,
47351 _swigt__p_wxPyDropTarget,
47352 _swigt__p_wxQuantize,
47353 _swigt__p_wxFocusEvent,
47354 _swigt__p_wxChildFocusEvent,
47355 _swigt__p_wxDropFilesEvent,
47356 _swigt__p_wxControlWithItems,
47357 _swigt__p_wxColour,
47358 _swigt__p_wxValidator,
47359 _swigt__p_wxPyValidator,
47360 0
47361 };
47362
47363
47364 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47365
47366 static swig_const_info swig_const_table[] = {
47367 {0, 0, 0, 0.0, 0, 0}};
47368
47369 #ifdef __cplusplus
47370 }
47371 #endif
47372
47373
47374 #ifdef __cplusplus
47375 extern "C" {
47376 #endif
47377
47378 /* Python-specific SWIG API */
47379 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47380 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47381 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47382
47383 /* -----------------------------------------------------------------------------
47384 * global variable support code.
47385 * ----------------------------------------------------------------------------- */
47386
47387 typedef struct swig_globalvar {
47388 char *name; /* Name of global variable */
47389 PyObject *(*get_attr)(); /* Return the current value */
47390 int (*set_attr)(PyObject *); /* Set the value */
47391 struct swig_globalvar *next;
47392 } swig_globalvar;
47393
47394 typedef struct swig_varlinkobject {
47395 PyObject_HEAD
47396 swig_globalvar *vars;
47397 } swig_varlinkobject;
47398
47399 static PyObject *
47400 swig_varlink_repr(swig_varlinkobject *v) {
47401 v = v;
47402 return PyString_FromString("<Swig global variables>");
47403 }
47404
47405 static int
47406 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47407 swig_globalvar *var;
47408 flags = flags;
47409 fprintf(fp,"Swig global variables { ");
47410 for (var = v->vars; var; var=var->next) {
47411 fprintf(fp,"%s", var->name);
47412 if (var->next) fprintf(fp,", ");
47413 }
47414 fprintf(fp," }\n");
47415 return 0;
47416 }
47417
47418 static PyObject *
47419 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47420 swig_globalvar *var = v->vars;
47421 while (var) {
47422 if (strcmp(var->name,n) == 0) {
47423 return (*var->get_attr)();
47424 }
47425 var = var->next;
47426 }
47427 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47428 return NULL;
47429 }
47430
47431 static int
47432 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47433 swig_globalvar *var = v->vars;
47434 while (var) {
47435 if (strcmp(var->name,n) == 0) {
47436 return (*var->set_attr)(p);
47437 }
47438 var = var->next;
47439 }
47440 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47441 return 1;
47442 }
47443
47444 static PyTypeObject varlinktype = {
47445 PyObject_HEAD_INIT(0)
47446 0, /* Number of items in variable part (ob_size) */
47447 (char *)"swigvarlink", /* Type name (tp_name) */
47448 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47449 0, /* Itemsize (tp_itemsize) */
47450 0, /* Deallocator (tp_dealloc) */
47451 (printfunc) swig_varlink_print, /* Print (tp_print) */
47452 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47453 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47454 0, /* tp_compare */
47455 (reprfunc) swig_varlink_repr, /* tp_repr */
47456 0, /* tp_as_number */
47457 0, /* tp_as_sequence */
47458 0, /* tp_as_mapping */
47459 0, /* tp_hash */
47460 0, /* tp_call */
47461 0, /* tp_str */
47462 0, /* tp_getattro */
47463 0, /* tp_setattro */
47464 0, /* tp_as_buffer */
47465 0, /* tp_flags */
47466 0, /* tp_doc */
47467 #if PY_VERSION_HEX >= 0x02000000
47468 0, /* tp_traverse */
47469 0, /* tp_clear */
47470 #endif
47471 #if PY_VERSION_HEX >= 0x02010000
47472 0, /* tp_richcompare */
47473 0, /* tp_weaklistoffset */
47474 #endif
47475 #if PY_VERSION_HEX >= 0x02020000
47476 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47477 #endif
47478 #if PY_VERSION_HEX >= 0x02030000
47479 0, /* tp_del */
47480 #endif
47481 #ifdef COUNT_ALLOCS
47482 0,0,0,0 /* tp_alloc -> tp_next */
47483 #endif
47484 };
47485
47486 /* Create a variable linking object for use later */
47487 static PyObject *
47488 SWIG_Python_newvarlink(void) {
47489 swig_varlinkobject *result = 0;
47490 result = PyMem_NEW(swig_varlinkobject,1);
47491 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47492 result->ob_type = &varlinktype;
47493 result->vars = 0;
47494 result->ob_refcnt = 0;
47495 Py_XINCREF((PyObject *) result);
47496 return ((PyObject*) result);
47497 }
47498
47499 static void
47500 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47501 swig_varlinkobject *v;
47502 swig_globalvar *gv;
47503 v= (swig_varlinkobject *) p;
47504 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47505 gv->name = (char *) malloc(strlen(name)+1);
47506 strcpy(gv->name,name);
47507 gv->get_attr = get_attr;
47508 gv->set_attr = set_attr;
47509 gv->next = v->vars;
47510 v->vars = gv;
47511 }
47512
47513 /* -----------------------------------------------------------------------------
47514 * constants/methods manipulation
47515 * ----------------------------------------------------------------------------- */
47516
47517 /* Install Constants */
47518 static void
47519 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47520 PyObject *obj = 0;
47521 size_t i;
47522 for (i = 0; constants[i].type; i++) {
47523 switch(constants[i].type) {
47524 case SWIG_PY_INT:
47525 obj = PyInt_FromLong(constants[i].lvalue);
47526 break;
47527 case SWIG_PY_FLOAT:
47528 obj = PyFloat_FromDouble(constants[i].dvalue);
47529 break;
47530 case SWIG_PY_STRING:
47531 if (constants[i].pvalue) {
47532 obj = PyString_FromString((char *) constants[i].pvalue);
47533 } else {
47534 Py_INCREF(Py_None);
47535 obj = Py_None;
47536 }
47537 break;
47538 case SWIG_PY_POINTER:
47539 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47540 break;
47541 case SWIG_PY_BINARY:
47542 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47543 break;
47544 default:
47545 obj = 0;
47546 break;
47547 }
47548 if (obj) {
47549 PyDict_SetItemString(d,constants[i].name,obj);
47550 Py_DECREF(obj);
47551 }
47552 }
47553 }
47554
47555 /* -----------------------------------------------------------------------------*/
47556 /* Fix SwigMethods to carry the callback ptrs when needed */
47557 /* -----------------------------------------------------------------------------*/
47558
47559 static void
47560 SWIG_Python_FixMethods(PyMethodDef *methods,
47561 swig_const_info *const_table,
47562 swig_type_info **types,
47563 swig_type_info **types_initial) {
47564 size_t i;
47565 for (i = 0; methods[i].ml_name; ++i) {
47566 char *c = methods[i].ml_doc;
47567 if (c && (c = strstr(c, "swig_ptr: "))) {
47568 int j;
47569 swig_const_info *ci = 0;
47570 char *name = c + 10;
47571 for (j = 0; const_table[j].type; j++) {
47572 if (strncmp(const_table[j].name, name,
47573 strlen(const_table[j].name)) == 0) {
47574 ci = &(const_table[j]);
47575 break;
47576 }
47577 }
47578 if (ci) {
47579 size_t shift = (ci->ptype) - types;
47580 swig_type_info *ty = types_initial[shift];
47581 size_t ldoc = (c - methods[i].ml_doc);
47582 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47583 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47584 char *buff = ndoc;
47585 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47586 strncpy(buff, methods[i].ml_doc, ldoc);
47587 buff += ldoc;
47588 strncpy(buff, "swig_ptr: ", 10);
47589 buff += 10;
47590 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47591 methods[i].ml_doc = ndoc;
47592 }
47593 }
47594 }
47595 }
47596
47597 /* -----------------------------------------------------------------------------*
47598 * Initialize type list
47599 * -----------------------------------------------------------------------------*/
47600
47601 #if PY_MAJOR_VERSION < 2
47602 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47603 is copied out of Python/modsupport.c in python version 2.3.4 */
47604 static int
47605 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47606 {
47607 PyObject *dict;
47608 if (!PyModule_Check(m)) {
47609 PyErr_SetString(PyExc_TypeError,
47610 "PyModule_AddObject() needs module as first arg");
47611 return -1;
47612 }
47613 if (!o) {
47614 PyErr_SetString(PyExc_TypeError,
47615 "PyModule_AddObject() needs non-NULL value");
47616 return -1;
47617 }
47618
47619 dict = PyModule_GetDict(m);
47620 if (dict == NULL) {
47621 /* Internal error -- modules must have a dict! */
47622 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47623 PyModule_GetName(m));
47624 return -1;
47625 }
47626 if (PyDict_SetItemString(dict, name, o))
47627 return -1;
47628 Py_DECREF(o);
47629 return 0;
47630 }
47631 #endif
47632
47633 static swig_type_info **
47634 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47635 static PyMethodDef swig_empty_runtime_method_table[] = {
47636 {
47637 NULL, NULL, 0, NULL
47638 }
47639 };/* Sentinel */
47640
47641 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47642 swig_empty_runtime_method_table);
47643 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47644 if (pointer && module) {
47645 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47646 }
47647 return type_list_handle;
47648 }
47649
47650 static swig_type_info **
47651 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47652 swig_type_info **type_pointer;
47653
47654 /* first check if module already created */
47655 type_pointer = SWIG_Python_GetTypeListHandle();
47656 if (type_pointer) {
47657 return type_pointer;
47658 } else {
47659 /* create a new module and variable */
47660 return SWIG_Python_SetTypeListHandle(type_list_handle);
47661 }
47662 }
47663
47664 #ifdef __cplusplus
47665 }
47666 #endif
47667
47668 /* -----------------------------------------------------------------------------*
47669 * Partial Init method
47670 * -----------------------------------------------------------------------------*/
47671
47672 #ifdef SWIG_LINK_RUNTIME
47673 #ifdef __cplusplus
47674 extern "C"
47675 #endif
47676 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47677 #endif
47678
47679 #ifdef __cplusplus
47680 extern "C"
47681 #endif
47682 SWIGEXPORT(void) SWIG_init(void) {
47683 static PyObject *SWIG_globals = 0;
47684 static int typeinit = 0;
47685 PyObject *m, *d;
47686 int i;
47687 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47688
47689 /* Fix SwigMethods to carry the callback ptrs when needed */
47690 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47691
47692 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47693 d = PyModule_GetDict(m);
47694
47695 if (!typeinit) {
47696 #ifdef SWIG_LINK_RUNTIME
47697 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47698 #else
47699 # ifndef SWIG_STATIC_RUNTIME
47700 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47701 # endif
47702 #endif
47703 for (i = 0; swig_types_initial[i]; i++) {
47704 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47705 }
47706 typeinit = 1;
47707 }
47708 SWIG_InstallConstants(d,swig_const_table);
47709
47710
47711 #ifndef wxPyUSE_EXPORT
47712 // Make our API structure a CObject so other modules can import it
47713 // from this module.
47714 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47715 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47716 Py_XDECREF(cobj);
47717 #endif
47718
47719 {
47720 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49377 }
49378 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49379 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49380 {
49381 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49532 }
49533 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49534 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49535 {
49536 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49543 }
49544
49545 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49546
49547
49548 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49549
49550 {
49551 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49558 }
49559 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49560 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49561 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49562 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49563 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49564 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49565 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49566 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49567 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49568 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49569 {
49570 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49574 }
49575 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49576 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49577 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49578 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49579 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49580 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49581 {
49582 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49628 }
49629 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49630 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49631 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49632 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49633 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49634 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49635 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49636 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49637 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49638 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49639 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49640 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49641 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49642 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49643 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49644 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49645 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49646 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49647 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49648 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49649 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49650 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49651 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49652 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49653 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49654 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49655 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49656 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49657 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49658 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49659 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49660 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49661 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49662 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49663 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49664 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49665 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49666 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49667 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49668 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49669 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49670 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49671 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49672 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49673 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49674 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49675 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49676 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49677 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49678 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49679 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49680 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49681 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49682 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49683 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49684 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49685 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49686 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49687 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49688 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49689 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49690 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49691 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49692 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49693 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49694 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49695 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49696 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49697 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49698 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49699 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49700 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49701 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49702 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49703 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49704 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49705 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49706 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49707 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49708 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49709 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49710 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49711 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49712 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49713 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49714 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49715 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49716 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49717 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49718 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49719 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49720 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49721 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49722 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49723 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49724 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49725 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49726 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49727 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49728 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49729 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49730 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49731 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49732 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49733 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49734 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49735 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49736 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49737 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49738 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49739 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49740 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49741 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49742 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49743 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49744 {
49745 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49782 }
49783 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49784 {
49785 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49801 }
49802 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49803 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49804 {
49805 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49818 }
49819 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49820 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49821 {
49822 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49829 }
49830 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49831 {
49832 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49887 }
49888
49889 // Initialize threading, some globals and such
49890 __wxPyPreStart(d);
49891
49892
49893 // Although these are defined in __version__ they need to be here too so
49894 // that an assert can be done to ensure that the wxPython and the wxWindows
49895 // versions match.
49896 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49897 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49898 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49899
49900 }
49901
wxWidgets (Impactor)