]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Docstring updates
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636
2637 void wxApp_CleanUp() {
2638 __wxPyCleanup();
2639 }
2640
2641
2642 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2643
2644
2645 SWIGINTERNSHORT int
2646 SWIG_AsCharPtr(PyObject *obj, char **val)
2647 {
2648 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2649 return 1;
2650 }
2651 if (val) {
2652 PyErr_Clear();
2653 SWIG_type_error("char *", obj);
2654 }
2655 return 0;
2656 }
2657
2658
2659 SWIGINTERN PyObject *
2660 SWIG_FromCharPtr(const char* cptr)
2661 {
2662 if (cptr) {
2663 size_t size = strlen(cptr);
2664 if (size > INT_MAX) {
2665 return SWIG_NewPointerObj((char*)(cptr),
2666 SWIG_TypeQuery("char *"), 0);
2667 } else {
2668 if (size != 0) {
2669 return PyString_FromStringAndSize(cptr, size);
2670 } else {
2671 return PyString_FromString(cptr);
2672 }
2673 }
2674 }
2675 Py_INCREF(Py_None);
2676 return Py_None;
2677 }
2678
2679
2680 #ifdef __WXMAC__
2681
2682 // A dummy class that raises an exception if used...
2683 class wxEventLoop
2684 {
2685 public:
2686 wxEventLoop() { wxPyRaiseNotImplemented(); }
2687 int Run() { return 0; }
2688 void Exit(int rc = 0) {}
2689 bool Pending() const { return false; }
2690 bool Dispatch() { return false; }
2691 bool IsRunning() const { return false; }
2692 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2693 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2694 };
2695
2696 #else
2697
2698 #include <wx/evtloop.h>
2699
2700 #endif
2701
2702
2703
2704 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2705 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2706 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2707 static PyObject *wxWindow_GetChildren(wxWindow *self){
2708 wxWindowList& list = self->GetChildren();
2709 return wxPy_ConvertList(&list);
2710 }
2711 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2712 #if wxUSE_HOTKEY
2713 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2714 #else
2715 return false;
2716 #endif
2717 }
2718 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2719
2720
2721
2722 return false;
2723
2724 }
2725 static long wxWindow_GetHandle(wxWindow *self){
2726 return wxPyGetWinHandle(self);
2727 }
2728 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2729 self->AssociateHandle((WXWidget)handle);
2730 }
2731
2732 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2733 return wxWindow::FindWindowById(id, parent);
2734 }
2735
2736 wxWindow* wxFindWindowByName( const wxString& name,
2737 const wxWindow *parent = NULL ) {
2738 return wxWindow::FindWindowByName(name, parent);
2739 }
2740
2741 wxWindow* wxFindWindowByLabel( const wxString& label,
2742 const wxWindow *parent = NULL ) {
2743 return wxWindow::FindWindowByLabel(label, parent);
2744 }
2745
2746
2747 #ifdef __WXMSW__
2748 #include <wx/msw/private.h> // to get wxGetWindowId
2749 #endif
2750
2751
2752 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2753 #ifdef __WXMSW__
2754 WXHWND hWnd = (WXHWND)_hWnd;
2755 long id = wxGetWindowId(hWnd);
2756 wxWindow* win = new wxWindow;
2757 parent->AddChild(win);
2758 win->SetEventHandler(win);
2759 win->SetHWND(hWnd);
2760 win->SetId(id);
2761 win->SubclassWin(hWnd);
2762 win->AdoptAttributesFromHWND();
2763 win->SetupColours();
2764 return win;
2765 #else
2766 wxPyRaiseNotImplemented();
2767 return NULL;
2768 #endif
2769 }
2770
2771
2772 PyObject* GetTopLevelWindows() {
2773 return wxPy_ConvertList(&wxTopLevelWindows);
2774 }
2775
2776
2777 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2778 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2779 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2780
2781 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2782
2783 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2784 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2785 wxMenuItemList& list = self->GetMenuItems();
2786 return wxPy_ConvertList(&list);
2787 }
2788 static const wxString wxPyControlNameStr(wxControlNameStr);
2789 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2790 if (clientData) {
2791 wxPyClientData* data = new wxPyClientData(clientData);
2792 return self->Append(item, data);
2793 } else
2794 return self->Append(item);
2795 }
2796 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Insert(item, pos, data);
2800 } else
2801 return self->Insert(item, pos);
2802 }
2803 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2804 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2805 if (data) {
2806 Py_INCREF(data->m_obj);
2807 return data->m_obj;
2808 } else {
2809 Py_INCREF(Py_None);
2810 return Py_None;
2811 }
2812 }
2813 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2814 wxPyClientData* data = new wxPyClientData(clientData);
2815 self->SetClientObject(n, data);
2816 }
2817
2818
2819 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2820 wxPyUserData* data = NULL;
2821 if ( userData ) {
2822 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2823 data = new wxPyUserData(userData);
2824 wxPyEndBlockThreads(blocked);
2825 }
2826 return new wxSizerItem(window, proportion, flag, border, data);
2827 }
2828 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(width, height, proportion, flag, border, data);
2836 }
2837 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2838 wxPyUserData* data = NULL;
2839 if ( userData ) {
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 data = new wxPyUserData(userData);
2842 wxPyEndBlockThreads(blocked);
2843 }
2844 return new wxSizerItem(sizer, proportion, flag, border, data);
2845 }
2846
2847 #include <float.h>
2848 SWIGINTERN int
2849 SWIG_CheckDoubleInRange(double value, double min_value,
2850 double max_value, const char* errmsg)
2851 {
2852 if (value < min_value) {
2853 if (errmsg) {
2854 PyErr_Format(PyExc_OverflowError,
2855 "value %g is less than %s minimum %g",
2856 value, errmsg, min_value);
2857 }
2858 return 0;
2859 } else if (value > max_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is greater than %s maximum %g",
2863 value, errmsg, max_value);
2864 }
2865 return 0;
2866 }
2867 return 1;
2868 }
2869
2870
2871 SWIGINTERN int
2872 SWIG_AsVal_float(PyObject *obj, float *val)
2873 {
2874 const char* errmsg = val ? "float" : (char*)0;
2875 double v;
2876 if (SWIG_AsVal_double(obj, &v)) {
2877 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2878 if (val) *val = (float)(v);
2879 return 1;
2880 } else {
2881 return 0;
2882 }
2883 } else {
2884 PyErr_Clear();
2885 }
2886 if (val) {
2887 SWIG_type_error(errmsg, obj);
2888 }
2889 return 0;
2890 }
2891
2892
2893 SWIGINTERNSHORT float
2894 SWIG_As_float(PyObject* obj)
2895 {
2896 float v;
2897 if (!SWIG_AsVal_float(obj, &v)) {
2898 /*
2899 this is needed to make valgrind/purify happier.
2900 */
2901 memset((void*)&v, 0, sizeof(float));
2902 }
2903 return v;
2904 }
2905
2906
2907 SWIGINTERNSHORT int
2908 SWIG_Check_float(PyObject* obj)
2909 {
2910 return SWIG_AsVal_float(obj, (float*)0);
2911 }
2912
2913
2914 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2915 #define SWIG_From_float PyFloat_FromDouble
2916 /*@@*/
2917
2918 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2919 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2920 if (data) {
2921 Py_INCREF(data->m_obj);
2922 return data->m_obj;
2923 } else {
2924 Py_INCREF(Py_None);
2925 return Py_None;
2926 }
2927 }
2928
2929 // Figure out the type of the sizer item
2930
2931 struct wxPySizerItemInfo {
2932 wxPySizerItemInfo()
2933 : window(NULL), sizer(NULL), gotSize(false),
2934 size(wxDefaultSize), gotPos(false), pos(-1)
2935 {}
2936
2937 wxWindow* window;
2938 wxSizer* sizer;
2939 bool gotSize;
2940 wxSize size;
2941 bool gotPos;
2942 int pos;
2943 };
2944
2945 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2946
2947 wxPySizerItemInfo info;
2948 wxSize size;
2949 wxSize* sizePtr = &size;
2950
2951 // Find out what the type of the item is
2952 // try wxWindow
2953 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2954 PyErr_Clear();
2955 info.window = NULL;
2956
2957 // try wxSizer
2958 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2959 PyErr_Clear();
2960 info.sizer = NULL;
2961
2962 // try wxSize or (w,h)
2963 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2964 info.size = *sizePtr;
2965 info.gotSize = true;
2966 }
2967
2968 // or a single int
2969 if (checkIdx && PyInt_Check(item)) {
2970 info.pos = PyInt_AsLong(item);
2971 info.gotPos = true;
2972 }
2973 }
2974 }
2975
2976 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2977 // no expected type, figure out what kind of error message to generate
2978 if ( !checkSize && !checkIdx )
2979 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2980 else if ( checkSize && !checkIdx )
2981 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2982 else if ( !checkSize && checkIdx)
2983 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2984 else
2985 // can this one happen?
2986 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2987 }
2988
2989 return info;
2990 }
2991
2992 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2993 if (!self->GetClientObject())
2994 self->SetClientObject(new wxPyOORClientData(_self));
2995 }
2996 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2997
2998 wxPyUserData* data = NULL;
2999 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3000 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3001 if ( userData && (info.window || info.sizer || info.gotSize) )
3002 data = new wxPyUserData(userData);
3003 wxPyEndBlockThreads(blocked);
3004
3005 // Now call the real Add method if a valid item type was found
3006 if ( info.window )
3007 return self->Add(info.window, proportion, flag, border, data);
3008 else if ( info.sizer )
3009 return self->Add(info.sizer, proportion, flag, border, data);
3010 else if (info.gotSize)
3011 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3012 proportion, flag, border, data);
3013 else
3014 return NULL;
3015 }
3016 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3017
3018 wxPyUserData* data = NULL;
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3021 if ( userData && (info.window || info.sizer || info.gotSize) )
3022 data = new wxPyUserData(userData);
3023 wxPyEndBlockThreads(blocked);
3024
3025 // Now call the real Insert method if a valid item type was found
3026 if ( info.window )
3027 return self->Insert(before, info.window, proportion, flag, border, data);
3028 else if ( info.sizer )
3029 return self->Insert(before, info.sizer, proportion, flag, border, data);
3030 else if (info.gotSize)
3031 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3032 proportion, flag, border, data);
3033 else
3034 return NULL;
3035 }
3036 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3037
3038 wxPyUserData* data = NULL;
3039 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3040 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3041 if ( userData && (info.window || info.sizer || info.gotSize) )
3042 data = new wxPyUserData(userData);
3043 wxPyEndBlockThreads(blocked);
3044
3045 // Now call the real Prepend method if a valid item type was found
3046 if ( info.window )
3047 return self->Prepend(info.window, proportion, flag, border, data);
3048 else if ( info.sizer )
3049 return self->Prepend(info.sizer, proportion, flag, border, data);
3050 else if (info.gotSize)
3051 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3052 proportion, flag, border, data);
3053 else
3054 return NULL;
3055 }
3056 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3057 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3059 wxPyEndBlockThreads(blocked);
3060 if ( info.window )
3061 return self->Remove(info.window);
3062 else if ( info.sizer )
3063 return self->Remove(info.sizer);
3064 else if ( info.gotPos )
3065 return self->Remove(info.pos);
3066 else
3067 return false;
3068 }
3069 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3072 wxPyEndBlockThreads(blocked);
3073 if ( info.window )
3074 return self->Detach(info.window);
3075 else if ( info.sizer )
3076 return self->Detach(info.sizer);
3077 else if ( info.gotPos )
3078 return self->Detach(info.pos);
3079 else
3080 return false;
3081 }
3082 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3085 wxPyEndBlockThreads(blocked);
3086 if ( info.window )
3087 return self->GetItem(info.window);
3088 else if ( info.sizer )
3089 return self->GetItem(info.sizer);
3090 else if ( info.gotPos )
3091 return self->GetItem(info.pos);
3092 else
3093 return NULL;
3094 }
3095 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3098 wxPyEndBlockThreads(blocked);
3099 if ( info.window )
3100 self->SetItemMinSize(info.window, size);
3101 else if ( info.sizer )
3102 self->SetItemMinSize(info.sizer, size);
3103 else if ( info.gotPos )
3104 self->SetItemMinSize(info.pos, size);
3105 }
3106 static PyObject *wxSizer_GetChildren(wxSizer *self){
3107 wxSizerItemList& list = self->GetChildren();
3108 return wxPy_ConvertList(&list);
3109 }
3110 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3113 wxPyEndBlockThreads(blocked);
3114 if ( info.window )
3115 return self->Show(info.window, show, recursive);
3116 else if ( info.sizer )
3117 return self->Show(info.sizer, show, recursive);
3118 else if ( info.gotPos )
3119 return self->Show(info.pos, show);
3120 else
3121 return false;
3122 }
3123 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3124 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3125 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3126 wxPyEndBlockThreads(blocked);
3127 if ( info.window )
3128 return self->IsShown(info.window);
3129 else if ( info.sizer )
3130 return self->IsShown(info.sizer);
3131 else if ( info.gotPos )
3132 return self->IsShown(info.pos);
3133 else
3134 return false;
3135 }
3136
3137 // See pyclasses.h
3138 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3139 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3140 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3141
3142
3143
3144
3145 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3146 {
3147 if (source == Py_None) {
3148 **obj = wxGBPosition(-1,-1);
3149 return true;
3150 }
3151 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3152 }
3153
3154 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3155 {
3156 if (source == Py_None) {
3157 **obj = wxGBSpan(-1,-1);
3158 return true;
3159 }
3160 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3161 }
3162
3163
3164 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3165 self->SetRow(row);
3166 self->SetCol(col);
3167 }
3168 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 PyObject* tup = PyTuple_New(2);
3171 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3172 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3173 wxPyEndBlockThreads(blocked);
3174 return tup;
3175 }
3176 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3177 self->SetRowspan(rowspan);
3178 self->SetColspan(colspan);
3179 }
3180 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 PyObject* tup = PyTuple_New(2);
3183 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3184 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3185 wxPyEndBlockThreads(blocked);
3186 return tup;
3187 }
3188 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3189 wxPyUserData* data = NULL;
3190 if ( userData ) {
3191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194 }
3195 return new wxGBSizerItem(window, pos, span, flag, border, data);
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3205 }
3206 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3207 wxPyUserData* data = NULL;
3208 if ( userData ) {
3209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3210 data = new wxPyUserData(userData);
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3214 }
3215 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3216 int row, col;
3217 self->GetEndPos(row, col);
3218 return wxGBPosition(row, col);
3219 }
3220 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3221
3222 wxPyUserData* data = NULL;
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3225 if ( userData && (info.window || info.sizer || info.gotSize) )
3226 data = new wxPyUserData(userData);
3227 wxPyEndBlockThreads(blocked);
3228
3229 // Now call the real Add method if a valid item type was found
3230 if ( info.window )
3231 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3232 else if ( info.sizer )
3233 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3234 else if (info.gotSize)
3235 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3236 pos, span, flag, border, data);
3237 return NULL;
3238 }
3239
3240
3241 #ifdef __cplusplus
3242 extern "C" {
3243 #endif
3244 static int _wrap_EmptyString_set(PyObject *) {
3245 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3246 return 1;
3247 }
3248
3249
3250 static PyObject *_wrap_EmptyString_get(void) {
3251 PyObject *pyobj;
3252
3253 {
3254 #if wxUSE_UNICODE
3255 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3256 #else
3257 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3258 #endif
3259 }
3260 return pyobj;
3261 }
3262
3263
3264 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3265 PyObject *resultobj;
3266 wxObject *arg1 = (wxObject *) 0 ;
3267 wxString result;
3268 PyObject * obj0 = 0 ;
3269 char *kwnames[] = {
3270 (char *) "self", NULL
3271 };
3272
3273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3275 if (SWIG_arg_fail(1)) SWIG_fail;
3276 {
3277 PyThreadState* __tstate = wxPyBeginAllowThreads();
3278 result = wxObject_GetClassName(arg1);
3279
3280 wxPyEndAllowThreads(__tstate);
3281 if (PyErr_Occurred()) SWIG_fail;
3282 }
3283 {
3284 #if wxUSE_UNICODE
3285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3286 #else
3287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3288 #endif
3289 }
3290 return resultobj;
3291 fail:
3292 return NULL;
3293 }
3294
3295
3296 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3297 PyObject *resultobj;
3298 wxObject *arg1 = (wxObject *) 0 ;
3299 PyObject * obj0 = 0 ;
3300 char *kwnames[] = {
3301 (char *) "self", NULL
3302 };
3303
3304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3306 if (SWIG_arg_fail(1)) SWIG_fail;
3307 {
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 wxObject_Destroy(arg1);
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 Py_INCREF(Py_None); resultobj = Py_None;
3315 return resultobj;
3316 fail:
3317 return NULL;
3318 }
3319
3320
3321 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3322 PyObject *obj;
3323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3324 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3325 Py_INCREF(obj);
3326 return Py_BuildValue((char *)"");
3327 }
3328 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj;
3330 wxSize *arg1 = (wxSize *) 0 ;
3331 int arg2 ;
3332 PyObject * obj0 = 0 ;
3333 PyObject * obj1 = 0 ;
3334 char *kwnames[] = {
3335 (char *) "self",(char *) "x", NULL
3336 };
3337
3338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3340 if (SWIG_arg_fail(1)) SWIG_fail;
3341 {
3342 arg2 = (int)(SWIG_As_int(obj1));
3343 if (SWIG_arg_fail(2)) SWIG_fail;
3344 }
3345 if (arg1) (arg1)->x = arg2;
3346
3347 Py_INCREF(Py_None); resultobj = Py_None;
3348 return resultobj;
3349 fail:
3350 return NULL;
3351 }
3352
3353
3354 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3355 PyObject *resultobj;
3356 wxSize *arg1 = (wxSize *) 0 ;
3357 int result;
3358 PyObject * obj0 = 0 ;
3359 char *kwnames[] = {
3360 (char *) "self", NULL
3361 };
3362
3363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3365 if (SWIG_arg_fail(1)) SWIG_fail;
3366 result = (int) ((arg1)->x);
3367
3368 {
3369 resultobj = SWIG_From_int((int)(result));
3370 }
3371 return resultobj;
3372 fail:
3373 return NULL;
3374 }
3375
3376
3377 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3378 PyObject *resultobj;
3379 wxSize *arg1 = (wxSize *) 0 ;
3380 int arg2 ;
3381 PyObject * obj0 = 0 ;
3382 PyObject * obj1 = 0 ;
3383 char *kwnames[] = {
3384 (char *) "self",(char *) "y", NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3389 if (SWIG_arg_fail(1)) SWIG_fail;
3390 {
3391 arg2 = (int)(SWIG_As_int(obj1));
3392 if (SWIG_arg_fail(2)) SWIG_fail;
3393 }
3394 if (arg1) (arg1)->y = arg2;
3395
3396 Py_INCREF(Py_None); resultobj = Py_None;
3397 return resultobj;
3398 fail:
3399 return NULL;
3400 }
3401
3402
3403 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3404 PyObject *resultobj;
3405 wxSize *arg1 = (wxSize *) 0 ;
3406 int result;
3407 PyObject * obj0 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "self", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 result = (int) ((arg1)->y);
3416
3417 {
3418 resultobj = SWIG_From_int((int)(result));
3419 }
3420 return resultobj;
3421 fail:
3422 return NULL;
3423 }
3424
3425
3426 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3427 PyObject *resultobj;
3428 int arg1 = (int) 0 ;
3429 int arg2 = (int) 0 ;
3430 wxSize *result;
3431 PyObject * obj0 = 0 ;
3432 PyObject * obj1 = 0 ;
3433 char *kwnames[] = {
3434 (char *) "w",(char *) "h", NULL
3435 };
3436
3437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3438 if (obj0) {
3439 {
3440 arg1 = (int)(SWIG_As_int(obj0));
3441 if (SWIG_arg_fail(1)) SWIG_fail;
3442 }
3443 }
3444 if (obj1) {
3445 {
3446 arg2 = (int)(SWIG_As_int(obj1));
3447 if (SWIG_arg_fail(2)) SWIG_fail;
3448 }
3449 }
3450 {
3451 PyThreadState* __tstate = wxPyBeginAllowThreads();
3452 result = (wxSize *)new wxSize(arg1,arg2);
3453
3454 wxPyEndAllowThreads(__tstate);
3455 if (PyErr_Occurred()) SWIG_fail;
3456 }
3457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3458 return resultobj;
3459 fail:
3460 return NULL;
3461 }
3462
3463
3464 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3465 PyObject *resultobj;
3466 wxSize *arg1 = (wxSize *) 0 ;
3467 PyObject * obj0 = 0 ;
3468 char *kwnames[] = {
3469 (char *) "self", NULL
3470 };
3471
3472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3474 if (SWIG_arg_fail(1)) SWIG_fail;
3475 {
3476 PyThreadState* __tstate = wxPyBeginAllowThreads();
3477 delete arg1;
3478
3479 wxPyEndAllowThreads(__tstate);
3480 if (PyErr_Occurred()) SWIG_fail;
3481 }
3482 Py_INCREF(Py_None); resultobj = Py_None;
3483 return resultobj;
3484 fail:
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 wxSize *arg2 = 0 ;
3493 bool result;
3494 wxSize temp2 ;
3495 PyObject * obj0 = 0 ;
3496 PyObject * obj1 = 0 ;
3497 char *kwnames[] = {
3498 (char *) "self",(char *) "sz", NULL
3499 };
3500
3501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 {
3505 arg2 = &temp2;
3506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3507 }
3508 {
3509 PyThreadState* __tstate = wxPyBeginAllowThreads();
3510 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3511
3512 wxPyEndAllowThreads(__tstate);
3513 if (PyErr_Occurred()) SWIG_fail;
3514 }
3515 {
3516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3517 }
3518 return resultobj;
3519 fail:
3520 return NULL;
3521 }
3522
3523
3524 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3525 PyObject *resultobj;
3526 wxSize *arg1 = (wxSize *) 0 ;
3527 wxSize *arg2 = 0 ;
3528 bool result;
3529 wxSize temp2 ;
3530 PyObject * obj0 = 0 ;
3531 PyObject * obj1 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self",(char *) "sz", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 {
3540 arg2 = &temp2;
3541 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 {
3551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3552 }
3553 return resultobj;
3554 fail:
3555 return NULL;
3556 }
3557
3558
3559 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3560 PyObject *resultobj;
3561 wxSize *arg1 = (wxSize *) 0 ;
3562 wxSize *arg2 = 0 ;
3563 wxSize result;
3564 wxSize temp2 ;
3565 PyObject * obj0 = 0 ;
3566 PyObject * obj1 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "self",(char *) "sz", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 {
3575 arg2 = &temp2;
3576 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3577 }
3578 {
3579 PyThreadState* __tstate = wxPyBeginAllowThreads();
3580 result = (arg1)->operator +((wxSize const &)*arg2);
3581
3582 wxPyEndAllowThreads(__tstate);
3583 if (PyErr_Occurred()) SWIG_fail;
3584 }
3585 {
3586 wxSize * resultptr;
3587 resultptr = new wxSize((wxSize &)(result));
3588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3589 }
3590 return resultobj;
3591 fail:
3592 return NULL;
3593 }
3594
3595
3596 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3597 PyObject *resultobj;
3598 wxSize *arg1 = (wxSize *) 0 ;
3599 wxSize *arg2 = 0 ;
3600 wxSize result;
3601 wxSize temp2 ;
3602 PyObject * obj0 = 0 ;
3603 PyObject * obj1 = 0 ;
3604 char *kwnames[] = {
3605 (char *) "self",(char *) "sz", NULL
3606 };
3607
3608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3610 if (SWIG_arg_fail(1)) SWIG_fail;
3611 {
3612 arg2 = &temp2;
3613 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3614 }
3615 {
3616 PyThreadState* __tstate = wxPyBeginAllowThreads();
3617 result = (arg1)->operator -((wxSize const &)*arg2);
3618
3619 wxPyEndAllowThreads(__tstate);
3620 if (PyErr_Occurred()) SWIG_fail;
3621 }
3622 {
3623 wxSize * resultptr;
3624 resultptr = new wxSize((wxSize &)(result));
3625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3626 }
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj;
3635 wxSize *arg1 = (wxSize *) 0 ;
3636 wxSize *arg2 = 0 ;
3637 wxSize temp2 ;
3638 PyObject * obj0 = 0 ;
3639 PyObject * obj1 = 0 ;
3640 char *kwnames[] = {
3641 (char *) "self",(char *) "sz", NULL
3642 };
3643
3644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3646 if (SWIG_arg_fail(1)) SWIG_fail;
3647 {
3648 arg2 = &temp2;
3649 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3650 }
3651 {
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 (arg1)->IncTo((wxSize const &)*arg2);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 Py_INCREF(Py_None); resultobj = Py_None;
3659 return resultobj;
3660 fail:
3661 return NULL;
3662 }
3663
3664
3665 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj;
3667 wxSize *arg1 = (wxSize *) 0 ;
3668 wxSize *arg2 = 0 ;
3669 wxSize temp2 ;
3670 PyObject * obj0 = 0 ;
3671 PyObject * obj1 = 0 ;
3672 char *kwnames[] = {
3673 (char *) "self",(char *) "sz", NULL
3674 };
3675
3676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3678 if (SWIG_arg_fail(1)) SWIG_fail;
3679 {
3680 arg2 = &temp2;
3681 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3682 }
3683 {
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 (arg1)->DecTo((wxSize const &)*arg2);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 return resultobj;
3692 fail:
3693 return NULL;
3694 }
3695
3696
3697 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3698 PyObject *resultobj;
3699 wxSize *arg1 = (wxSize *) 0 ;
3700 int arg2 ;
3701 int arg3 ;
3702 PyObject * obj0 = 0 ;
3703 PyObject * obj1 = 0 ;
3704 PyObject * obj2 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "self",(char *) "w",(char *) "h", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 {
3713 arg2 = (int)(SWIG_As_int(obj1));
3714 if (SWIG_arg_fail(2)) SWIG_fail;
3715 }
3716 {
3717 arg3 = (int)(SWIG_As_int(obj2));
3718 if (SWIG_arg_fail(3)) SWIG_fail;
3719 }
3720 {
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 (arg1)->Set(arg2,arg3);
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 Py_INCREF(Py_None); resultobj = Py_None;
3728 return resultobj;
3729 fail:
3730 return NULL;
3731 }
3732
3733
3734 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3735 PyObject *resultobj;
3736 wxSize *arg1 = (wxSize *) 0 ;
3737 int arg2 ;
3738 PyObject * obj0 = 0 ;
3739 PyObject * obj1 = 0 ;
3740 char *kwnames[] = {
3741 (char *) "self",(char *) "w", NULL
3742 };
3743
3744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3746 if (SWIG_arg_fail(1)) SWIG_fail;
3747 {
3748 arg2 = (int)(SWIG_As_int(obj1));
3749 if (SWIG_arg_fail(2)) SWIG_fail;
3750 }
3751 {
3752 PyThreadState* __tstate = wxPyBeginAllowThreads();
3753 (arg1)->SetWidth(arg2);
3754
3755 wxPyEndAllowThreads(__tstate);
3756 if (PyErr_Occurred()) SWIG_fail;
3757 }
3758 Py_INCREF(Py_None); resultobj = Py_None;
3759 return resultobj;
3760 fail:
3761 return NULL;
3762 }
3763
3764
3765 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3766 PyObject *resultobj;
3767 wxSize *arg1 = (wxSize *) 0 ;
3768 int arg2 ;
3769 PyObject * obj0 = 0 ;
3770 PyObject * obj1 = 0 ;
3771 char *kwnames[] = {
3772 (char *) "self",(char *) "h", NULL
3773 };
3774
3775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3777 if (SWIG_arg_fail(1)) SWIG_fail;
3778 {
3779 arg2 = (int)(SWIG_As_int(obj1));
3780 if (SWIG_arg_fail(2)) SWIG_fail;
3781 }
3782 {
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 (arg1)->SetHeight(arg2);
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 Py_INCREF(Py_None); resultobj = Py_None;
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 wxSize *arg1 = (wxSize *) 0 ;
3799 int result;
3800 PyObject * obj0 = 0 ;
3801 char *kwnames[] = {
3802 (char *) "self", NULL
3803 };
3804
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3807 if (SWIG_arg_fail(1)) SWIG_fail;
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (int)((wxSize const *)arg1)->GetWidth();
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = SWIG_From_int((int)(result));
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 wxSize *arg1 = (wxSize *) 0 ;
3827 int result;
3828 PyObject * obj0 = 0 ;
3829 char *kwnames[] = {
3830 (char *) "self", NULL
3831 };
3832
3833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3835 if (SWIG_arg_fail(1)) SWIG_fail;
3836 {
3837 PyThreadState* __tstate = wxPyBeginAllowThreads();
3838 result = (int)((wxSize const *)arg1)->GetHeight();
3839
3840 wxPyEndAllowThreads(__tstate);
3841 if (PyErr_Occurred()) SWIG_fail;
3842 }
3843 {
3844 resultobj = SWIG_From_int((int)(result));
3845 }
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj;
3854 wxSize *arg1 = (wxSize *) 0 ;
3855 bool result;
3856 PyObject * obj0 = 0 ;
3857 char *kwnames[] = {
3858 (char *) "self", NULL
3859 };
3860
3861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3863 if (SWIG_arg_fail(1)) SWIG_fail;
3864 {
3865 PyThreadState* __tstate = wxPyBeginAllowThreads();
3866 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3867
3868 wxPyEndAllowThreads(__tstate);
3869 if (PyErr_Occurred()) SWIG_fail;
3870 }
3871 {
3872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3873 }
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj;
3882 wxSize *arg1 = (wxSize *) 0 ;
3883 wxSize *arg2 = 0 ;
3884 wxSize temp2 ;
3885 PyObject * obj0 = 0 ;
3886 PyObject * obj1 = 0 ;
3887 char *kwnames[] = {
3888 (char *) "self",(char *) "size", NULL
3889 };
3890
3891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3893 if (SWIG_arg_fail(1)) SWIG_fail;
3894 {
3895 arg2 = &temp2;
3896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3897 }
3898 {
3899 PyThreadState* __tstate = wxPyBeginAllowThreads();
3900 (arg1)->SetDefaults((wxSize const &)*arg2);
3901
3902 wxPyEndAllowThreads(__tstate);
3903 if (PyErr_Occurred()) SWIG_fail;
3904 }
3905 Py_INCREF(Py_None); resultobj = Py_None;
3906 return resultobj;
3907 fail:
3908 return NULL;
3909 }
3910
3911
3912 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3913 PyObject *resultobj;
3914 wxSize *arg1 = (wxSize *) 0 ;
3915 PyObject *result;
3916 PyObject * obj0 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 PyThreadState* __tstate = wxPyBeginAllowThreads();
3926 result = (PyObject *)wxSize_Get(arg1);
3927
3928 wxPyEndAllowThreads(__tstate);
3929 if (PyErr_Occurred()) SWIG_fail;
3930 }
3931 resultobj = result;
3932 return resultobj;
3933 fail:
3934 return NULL;
3935 }
3936
3937
3938 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3939 PyObject *obj;
3940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3941 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3942 Py_INCREF(obj);
3943 return Py_BuildValue((char *)"");
3944 }
3945 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3946 PyObject *resultobj;
3947 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3948 double arg2 ;
3949 PyObject * obj0 = 0 ;
3950 PyObject * obj1 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self",(char *) "x", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 {
3959 arg2 = (double)(SWIG_As_double(obj1));
3960 if (SWIG_arg_fail(2)) SWIG_fail;
3961 }
3962 if (arg1) (arg1)->x = arg2;
3963
3964 Py_INCREF(Py_None); resultobj = Py_None;
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3972 PyObject *resultobj;
3973 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3974 double result;
3975 PyObject * obj0 = 0 ;
3976 char *kwnames[] = {
3977 (char *) "self", NULL
3978 };
3979
3980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3982 if (SWIG_arg_fail(1)) SWIG_fail;
3983 result = (double) ((arg1)->x);
3984
3985 {
3986 resultobj = SWIG_From_double((double)(result));
3987 }
3988 return resultobj;
3989 fail:
3990 return NULL;
3991 }
3992
3993
3994 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3995 PyObject *resultobj;
3996 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3997 double arg2 ;
3998 PyObject * obj0 = 0 ;
3999 PyObject * obj1 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "self",(char *) "y", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4006 if (SWIG_arg_fail(1)) SWIG_fail;
4007 {
4008 arg2 = (double)(SWIG_As_double(obj1));
4009 if (SWIG_arg_fail(2)) SWIG_fail;
4010 }
4011 if (arg1) (arg1)->y = arg2;
4012
4013 Py_INCREF(Py_None); resultobj = Py_None;
4014 return resultobj;
4015 fail:
4016 return NULL;
4017 }
4018
4019
4020 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4021 PyObject *resultobj;
4022 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4023 double result;
4024 PyObject * obj0 = 0 ;
4025 char *kwnames[] = {
4026 (char *) "self", NULL
4027 };
4028
4029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4031 if (SWIG_arg_fail(1)) SWIG_fail;
4032 result = (double) ((arg1)->y);
4033
4034 {
4035 resultobj = SWIG_From_double((double)(result));
4036 }
4037 return resultobj;
4038 fail:
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj;
4045 double arg1 = (double) 0.0 ;
4046 double arg2 = (double) 0.0 ;
4047 wxRealPoint *result;
4048 PyObject * obj0 = 0 ;
4049 PyObject * obj1 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "x",(char *) "y", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4055 if (obj0) {
4056 {
4057 arg1 = (double)(SWIG_As_double(obj0));
4058 if (SWIG_arg_fail(1)) SWIG_fail;
4059 }
4060 }
4061 if (obj1) {
4062 {
4063 arg2 = (double)(SWIG_As_double(obj1));
4064 if (SWIG_arg_fail(2)) SWIG_fail;
4065 }
4066 }
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4084 PyObject * obj0 = 0 ;
4085 char *kwnames[] = {
4086 (char *) "self", NULL
4087 };
4088
4089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4091 if (SWIG_arg_fail(1)) SWIG_fail;
4092 {
4093 PyThreadState* __tstate = wxPyBeginAllowThreads();
4094 delete arg1;
4095
4096 wxPyEndAllowThreads(__tstate);
4097 if (PyErr_Occurred()) SWIG_fail;
4098 }
4099 Py_INCREF(Py_None); resultobj = Py_None;
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 wxRealPoint *arg2 = 0 ;
4110 bool result;
4111 wxRealPoint temp2 ;
4112 PyObject * obj0 = 0 ;
4113 PyObject * obj1 = 0 ;
4114 char *kwnames[] = {
4115 (char *) "self",(char *) "pt", NULL
4116 };
4117
4118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 {
4122 arg2 = &temp2;
4123 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4124 }
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4128
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 {
4133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4134 }
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4144 wxRealPoint *arg2 = 0 ;
4145 bool result;
4146 wxRealPoint temp2 ;
4147 PyObject * obj0 = 0 ;
4148 PyObject * obj1 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "self",(char *) "pt", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4155 if (SWIG_arg_fail(1)) SWIG_fail;
4156 {
4157 arg2 = &temp2;
4158 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 {
4168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4169 }
4170 return resultobj;
4171 fail:
4172 return NULL;
4173 }
4174
4175
4176 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4177 PyObject *resultobj;
4178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4179 wxRealPoint *arg2 = 0 ;
4180 wxRealPoint result;
4181 wxRealPoint temp2 ;
4182 PyObject * obj0 = 0 ;
4183 PyObject * obj1 = 0 ;
4184 char *kwnames[] = {
4185 (char *) "self",(char *) "pt", NULL
4186 };
4187
4188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4190 if (SWIG_arg_fail(1)) SWIG_fail;
4191 {
4192 arg2 = &temp2;
4193 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4194 }
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 {
4203 wxRealPoint * resultptr;
4204 resultptr = new wxRealPoint((wxRealPoint &)(result));
4205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4206 }
4207 return resultobj;
4208 fail:
4209 return NULL;
4210 }
4211
4212
4213 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4214 PyObject *resultobj;
4215 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4216 wxRealPoint *arg2 = 0 ;
4217 wxRealPoint result;
4218 wxRealPoint temp2 ;
4219 PyObject * obj0 = 0 ;
4220 PyObject * obj1 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "self",(char *) "pt", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4227 if (SWIG_arg_fail(1)) SWIG_fail;
4228 {
4229 arg2 = &temp2;
4230 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4231 }
4232 {
4233 PyThreadState* __tstate = wxPyBeginAllowThreads();
4234 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4235
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 {
4240 wxRealPoint * resultptr;
4241 resultptr = new wxRealPoint((wxRealPoint &)(result));
4242 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4243 }
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj;
4252 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4253 double arg2 ;
4254 double arg3 ;
4255 PyObject * obj0 = 0 ;
4256 PyObject * obj1 = 0 ;
4257 PyObject * obj2 = 0 ;
4258 char *kwnames[] = {
4259 (char *) "self",(char *) "x",(char *) "y", NULL
4260 };
4261
4262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4264 if (SWIG_arg_fail(1)) SWIG_fail;
4265 {
4266 arg2 = (double)(SWIG_As_double(obj1));
4267 if (SWIG_arg_fail(2)) SWIG_fail;
4268 }
4269 {
4270 arg3 = (double)(SWIG_As_double(obj2));
4271 if (SWIG_arg_fail(3)) SWIG_fail;
4272 }
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 wxRealPoint_Set(arg1,arg2,arg3);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 Py_INCREF(Py_None); resultobj = Py_None;
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4288 PyObject *resultobj;
4289 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4290 PyObject *result;
4291 PyObject * obj0 = 0 ;
4292 char *kwnames[] = {
4293 (char *) "self", NULL
4294 };
4295
4296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4298 if (SWIG_arg_fail(1)) SWIG_fail;
4299 {
4300 PyThreadState* __tstate = wxPyBeginAllowThreads();
4301 result = (PyObject *)wxRealPoint_Get(arg1);
4302
4303 wxPyEndAllowThreads(__tstate);
4304 if (PyErr_Occurred()) SWIG_fail;
4305 }
4306 resultobj = result;
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4314 PyObject *obj;
4315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4316 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4317 Py_INCREF(obj);
4318 return Py_BuildValue((char *)"");
4319 }
4320 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4321 PyObject *resultobj;
4322 wxPoint *arg1 = (wxPoint *) 0 ;
4323 int arg2 ;
4324 PyObject * obj0 = 0 ;
4325 PyObject * obj1 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "self",(char *) "x", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4332 if (SWIG_arg_fail(1)) SWIG_fail;
4333 {
4334 arg2 = (int)(SWIG_As_int(obj1));
4335 if (SWIG_arg_fail(2)) SWIG_fail;
4336 }
4337 if (arg1) (arg1)->x = arg2;
4338
4339 Py_INCREF(Py_None); resultobj = Py_None;
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxPoint *arg1 = (wxPoint *) 0 ;
4349 int result;
4350 PyObject * obj0 = 0 ;
4351 char *kwnames[] = {
4352 (char *) "self", NULL
4353 };
4354
4355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4357 if (SWIG_arg_fail(1)) SWIG_fail;
4358 result = (int) ((arg1)->x);
4359
4360 {
4361 resultobj = SWIG_From_int((int)(result));
4362 }
4363 return resultobj;
4364 fail:
4365 return NULL;
4366 }
4367
4368
4369 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj;
4371 wxPoint *arg1 = (wxPoint *) 0 ;
4372 int arg2 ;
4373 PyObject * obj0 = 0 ;
4374 PyObject * obj1 = 0 ;
4375 char *kwnames[] = {
4376 (char *) "self",(char *) "y", NULL
4377 };
4378
4379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4381 if (SWIG_arg_fail(1)) SWIG_fail;
4382 {
4383 arg2 = (int)(SWIG_As_int(obj1));
4384 if (SWIG_arg_fail(2)) SWIG_fail;
4385 }
4386 if (arg1) (arg1)->y = arg2;
4387
4388 Py_INCREF(Py_None); resultobj = Py_None;
4389 return resultobj;
4390 fail:
4391 return NULL;
4392 }
4393
4394
4395 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4396 PyObject *resultobj;
4397 wxPoint *arg1 = (wxPoint *) 0 ;
4398 int result;
4399 PyObject * obj0 = 0 ;
4400 char *kwnames[] = {
4401 (char *) "self", NULL
4402 };
4403
4404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 result = (int) ((arg1)->y);
4408
4409 {
4410 resultobj = SWIG_From_int((int)(result));
4411 }
4412 return resultobj;
4413 fail:
4414 return NULL;
4415 }
4416
4417
4418 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4419 PyObject *resultobj;
4420 int arg1 = (int) 0 ;
4421 int arg2 = (int) 0 ;
4422 wxPoint *result;
4423 PyObject * obj0 = 0 ;
4424 PyObject * obj1 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "x",(char *) "y", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4430 if (obj0) {
4431 {
4432 arg1 = (int)(SWIG_As_int(obj0));
4433 if (SWIG_arg_fail(1)) SWIG_fail;
4434 }
4435 }
4436 if (obj1) {
4437 {
4438 arg2 = (int)(SWIG_As_int(obj1));
4439 if (SWIG_arg_fail(2)) SWIG_fail;
4440 }
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = (wxPoint *)new wxPoint(arg1,arg2);
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj;
4458 wxPoint *arg1 = (wxPoint *) 0 ;
4459 PyObject * obj0 = 0 ;
4460 char *kwnames[] = {
4461 (char *) "self", NULL
4462 };
4463
4464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4466 if (SWIG_arg_fail(1)) SWIG_fail;
4467 {
4468 PyThreadState* __tstate = wxPyBeginAllowThreads();
4469 delete arg1;
4470
4471 wxPyEndAllowThreads(__tstate);
4472 if (PyErr_Occurred()) SWIG_fail;
4473 }
4474 Py_INCREF(Py_None); resultobj = Py_None;
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 wxPoint *arg2 = 0 ;
4485 bool result;
4486 wxPoint temp2 ;
4487 PyObject * obj0 = 0 ;
4488 PyObject * obj1 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "self",(char *) "pt", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4495 if (SWIG_arg_fail(1)) SWIG_fail;
4496 {
4497 arg2 = &temp2;
4498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4499 }
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4503
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4509 }
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxPoint *arg1 = (wxPoint *) 0 ;
4519 wxPoint *arg2 = 0 ;
4520 bool result;
4521 wxPoint temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "pt", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4544 }
4545 return resultobj;
4546 fail:
4547 return NULL;
4548 }
4549
4550
4551 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4552 PyObject *resultobj;
4553 wxPoint *arg1 = (wxPoint *) 0 ;
4554 wxPoint *arg2 = 0 ;
4555 wxPoint result;
4556 wxPoint temp2 ;
4557 PyObject * obj0 = 0 ;
4558 PyObject * obj1 = 0 ;
4559 char *kwnames[] = {
4560 (char *) "self",(char *) "pt", NULL
4561 };
4562
4563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4565 if (SWIG_arg_fail(1)) SWIG_fail;
4566 {
4567 arg2 = &temp2;
4568 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (arg1)->operator +((wxPoint const &)*arg2);
4573
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 {
4578 wxPoint * resultptr;
4579 resultptr = new wxPoint((wxPoint &)(result));
4580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj;
4590 wxPoint *arg1 = (wxPoint *) 0 ;
4591 wxPoint *arg2 = 0 ;
4592 wxPoint result;
4593 wxPoint temp2 ;
4594 PyObject * obj0 = 0 ;
4595 PyObject * obj1 = 0 ;
4596 char *kwnames[] = {
4597 (char *) "self",(char *) "pt", NULL
4598 };
4599
4600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4602 if (SWIG_arg_fail(1)) SWIG_fail;
4603 {
4604 arg2 = &temp2;
4605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4606 }
4607 {
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 result = (arg1)->operator -((wxPoint const &)*arg2);
4610
4611 wxPyEndAllowThreads(__tstate);
4612 if (PyErr_Occurred()) SWIG_fail;
4613 }
4614 {
4615 wxPoint * resultptr;
4616 resultptr = new wxPoint((wxPoint &)(result));
4617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4618 }
4619 return resultobj;
4620 fail:
4621 return NULL;
4622 }
4623
4624
4625 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4626 PyObject *resultobj;
4627 wxPoint *arg1 = (wxPoint *) 0 ;
4628 wxPoint *arg2 = 0 ;
4629 wxPoint *result;
4630 wxPoint temp2 ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 char *kwnames[] = {
4634 (char *) "self",(char *) "pt", NULL
4635 };
4636
4637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4639 if (SWIG_arg_fail(1)) SWIG_fail;
4640 {
4641 arg2 = &temp2;
4642 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4643 }
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 {
4647 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4648 result = (wxPoint *) &_result_ref;
4649 }
4650
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj;
4663 wxPoint *arg1 = (wxPoint *) 0 ;
4664 wxPoint *arg2 = 0 ;
4665 wxPoint *result;
4666 wxPoint temp2 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char *kwnames[] = {
4670 (char *) "self",(char *) "pt", NULL
4671 };
4672
4673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4675 if (SWIG_arg_fail(1)) SWIG_fail;
4676 {
4677 arg2 = &temp2;
4678 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4679 }
4680 {
4681 PyThreadState* __tstate = wxPyBeginAllowThreads();
4682 {
4683 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4684 result = (wxPoint *) &_result_ref;
4685 }
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxPoint *arg1 = (wxPoint *) 0 ;
4700 long arg2 ;
4701 long arg3 ;
4702 PyObject * obj0 = 0 ;
4703 PyObject * obj1 = 0 ;
4704 PyObject * obj2 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self",(char *) "x",(char *) "y", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 arg2 = (long)(SWIG_As_long(obj1));
4714 if (SWIG_arg_fail(2)) SWIG_fail;
4715 }
4716 {
4717 arg3 = (long)(SWIG_As_long(obj2));
4718 if (SWIG_arg_fail(3)) SWIG_fail;
4719 }
4720 {
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 wxPoint_Set(arg1,arg2,arg3);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 Py_INCREF(Py_None); resultobj = Py_None;
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4735 PyObject *resultobj;
4736 wxPoint *arg1 = (wxPoint *) 0 ;
4737 PyObject *result;
4738 PyObject * obj0 = 0 ;
4739 char *kwnames[] = {
4740 (char *) "self", NULL
4741 };
4742
4743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4745 if (SWIG_arg_fail(1)) SWIG_fail;
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (PyObject *)wxPoint_Get(arg1);
4749
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = result;
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4761 PyObject *obj;
4762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4763 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4764 Py_INCREF(obj);
4765 return Py_BuildValue((char *)"");
4766 }
4767 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4768 PyObject *resultobj;
4769 int arg1 = (int) 0 ;
4770 int arg2 = (int) 0 ;
4771 int arg3 = (int) 0 ;
4772 int arg4 = (int) 0 ;
4773 wxRect *result;
4774 PyObject * obj0 = 0 ;
4775 PyObject * obj1 = 0 ;
4776 PyObject * obj2 = 0 ;
4777 PyObject * obj3 = 0 ;
4778 char *kwnames[] = {
4779 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4780 };
4781
4782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4783 if (obj0) {
4784 {
4785 arg1 = (int)(SWIG_As_int(obj0));
4786 if (SWIG_arg_fail(1)) SWIG_fail;
4787 }
4788 }
4789 if (obj1) {
4790 {
4791 arg2 = (int)(SWIG_As_int(obj1));
4792 if (SWIG_arg_fail(2)) SWIG_fail;
4793 }
4794 }
4795 if (obj2) {
4796 {
4797 arg3 = (int)(SWIG_As_int(obj2));
4798 if (SWIG_arg_fail(3)) SWIG_fail;
4799 }
4800 }
4801 if (obj3) {
4802 {
4803 arg4 = (int)(SWIG_As_int(obj3));
4804 if (SWIG_arg_fail(4)) SWIG_fail;
4805 }
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4810
4811 wxPyEndAllowThreads(__tstate);
4812 if (PyErr_Occurred()) SWIG_fail;
4813 }
4814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4815 return resultobj;
4816 fail:
4817 return NULL;
4818 }
4819
4820
4821 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4822 PyObject *resultobj;
4823 wxPoint *arg1 = 0 ;
4824 wxPoint *arg2 = 0 ;
4825 wxRect *result;
4826 wxPoint temp1 ;
4827 wxPoint temp2 ;
4828 PyObject * obj0 = 0 ;
4829 PyObject * obj1 = 0 ;
4830 char *kwnames[] = {
4831 (char *) "topLeft",(char *) "bottomRight", NULL
4832 };
4833
4834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4835 {
4836 arg1 = &temp1;
4837 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4838 }
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4846
4847 wxPyEndAllowThreads(__tstate);
4848 if (PyErr_Occurred()) SWIG_fail;
4849 }
4850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4851 return resultobj;
4852 fail:
4853 return NULL;
4854 }
4855
4856
4857 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4858 PyObject *resultobj;
4859 wxPoint *arg1 = 0 ;
4860 wxSize *arg2 = 0 ;
4861 wxRect *result;
4862 wxPoint temp1 ;
4863 wxSize temp2 ;
4864 PyObject * obj0 = 0 ;
4865 PyObject * obj1 = 0 ;
4866 char *kwnames[] = {
4867 (char *) "pos",(char *) "size", NULL
4868 };
4869
4870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4871 {
4872 arg1 = &temp1;
4873 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4874 }
4875 {
4876 arg2 = &temp2;
4877 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4878 }
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4882
4883 wxPyEndAllowThreads(__tstate);
4884 if (PyErr_Occurred()) SWIG_fail;
4885 }
4886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj;
4895 wxSize *arg1 = 0 ;
4896 wxRect *result;
4897 wxSize temp1 ;
4898 PyObject * obj0 = 0 ;
4899 char *kwnames[] = {
4900 (char *) "size", NULL
4901 };
4902
4903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4904 {
4905 arg1 = &temp1;
4906 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4911
4912 wxPyEndAllowThreads(__tstate);
4913 if (PyErr_Occurred()) SWIG_fail;
4914 }
4915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4916 return resultobj;
4917 fail:
4918 return NULL;
4919 }
4920
4921
4922 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4923 PyObject *resultobj;
4924 wxRect *arg1 = (wxRect *) 0 ;
4925 PyObject * obj0 = 0 ;
4926 char *kwnames[] = {
4927 (char *) "self", NULL
4928 };
4929
4930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4932 if (SWIG_arg_fail(1)) SWIG_fail;
4933 {
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 delete arg1;
4936
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 Py_INCREF(Py_None); resultobj = Py_None;
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4948 PyObject *resultobj;
4949 wxRect *arg1 = (wxRect *) 0 ;
4950 int result;
4951 PyObject * obj0 = 0 ;
4952 char *kwnames[] = {
4953 (char *) "self", NULL
4954 };
4955
4956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4958 if (SWIG_arg_fail(1)) SWIG_fail;
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (int)((wxRect const *)arg1)->GetX();
4962
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = SWIG_From_int((int)(result));
4968 }
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj;
4977 wxRect *arg1 = (wxRect *) 0 ;
4978 int arg2 ;
4979 PyObject * obj0 = 0 ;
4980 PyObject * obj1 = 0 ;
4981 char *kwnames[] = {
4982 (char *) "self",(char *) "x", NULL
4983 };
4984
4985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4987 if (SWIG_arg_fail(1)) SWIG_fail;
4988 {
4989 arg2 = (int)(SWIG_As_int(obj1));
4990 if (SWIG_arg_fail(2)) SWIG_fail;
4991 }
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 (arg1)->SetX(arg2);
4995
4996 wxPyEndAllowThreads(__tstate);
4997 if (PyErr_Occurred()) SWIG_fail;
4998 }
4999 Py_INCREF(Py_None); resultobj = Py_None;
5000 return resultobj;
5001 fail:
5002 return NULL;
5003 }
5004
5005
5006 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5007 PyObject *resultobj;
5008 wxRect *arg1 = (wxRect *) 0 ;
5009 int result;
5010 PyObject * obj0 = 0 ;
5011 char *kwnames[] = {
5012 (char *) "self", NULL
5013 };
5014
5015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5017 if (SWIG_arg_fail(1)) SWIG_fail;
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (int)(arg1)->GetY();
5021
5022 wxPyEndAllowThreads(__tstate);
5023 if (PyErr_Occurred()) SWIG_fail;
5024 }
5025 {
5026 resultobj = SWIG_From_int((int)(result));
5027 }
5028 return resultobj;
5029 fail:
5030 return NULL;
5031 }
5032
5033
5034 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5035 PyObject *resultobj;
5036 wxRect *arg1 = (wxRect *) 0 ;
5037 int arg2 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 char *kwnames[] = {
5041 (char *) "self",(char *) "y", NULL
5042 };
5043
5044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5046 if (SWIG_arg_fail(1)) SWIG_fail;
5047 {
5048 arg2 = (int)(SWIG_As_int(obj1));
5049 if (SWIG_arg_fail(2)) SWIG_fail;
5050 }
5051 {
5052 PyThreadState* __tstate = wxPyBeginAllowThreads();
5053 (arg1)->SetY(arg2);
5054
5055 wxPyEndAllowThreads(__tstate);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 Py_INCREF(Py_None); resultobj = Py_None;
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj;
5067 wxRect *arg1 = (wxRect *) 0 ;
5068 int result;
5069 PyObject * obj0 = 0 ;
5070 char *kwnames[] = {
5071 (char *) "self", NULL
5072 };
5073
5074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5076 if (SWIG_arg_fail(1)) SWIG_fail;
5077 {
5078 PyThreadState* __tstate = wxPyBeginAllowThreads();
5079 result = (int)((wxRect const *)arg1)->GetWidth();
5080
5081 wxPyEndAllowThreads(__tstate);
5082 if (PyErr_Occurred()) SWIG_fail;
5083 }
5084 {
5085 resultobj = SWIG_From_int((int)(result));
5086 }
5087 return resultobj;
5088 fail:
5089 return NULL;
5090 }
5091
5092
5093 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5094 PyObject *resultobj;
5095 wxRect *arg1 = (wxRect *) 0 ;
5096 int arg2 ;
5097 PyObject * obj0 = 0 ;
5098 PyObject * obj1 = 0 ;
5099 char *kwnames[] = {
5100 (char *) "self",(char *) "w", NULL
5101 };
5102
5103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5105 if (SWIG_arg_fail(1)) SWIG_fail;
5106 {
5107 arg2 = (int)(SWIG_As_int(obj1));
5108 if (SWIG_arg_fail(2)) SWIG_fail;
5109 }
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 (arg1)->SetWidth(arg2);
5113
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 Py_INCREF(Py_None); resultobj = Py_None;
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5125 PyObject *resultobj;
5126 wxRect *arg1 = (wxRect *) 0 ;
5127 int result;
5128 PyObject * obj0 = 0 ;
5129 char *kwnames[] = {
5130 (char *) "self", NULL
5131 };
5132
5133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5135 if (SWIG_arg_fail(1)) SWIG_fail;
5136 {
5137 PyThreadState* __tstate = wxPyBeginAllowThreads();
5138 result = (int)((wxRect const *)arg1)->GetHeight();
5139
5140 wxPyEndAllowThreads(__tstate);
5141 if (PyErr_Occurred()) SWIG_fail;
5142 }
5143 {
5144 resultobj = SWIG_From_int((int)(result));
5145 }
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5153 PyObject *resultobj;
5154 wxRect *arg1 = (wxRect *) 0 ;
5155 int arg2 ;
5156 PyObject * obj0 = 0 ;
5157 PyObject * obj1 = 0 ;
5158 char *kwnames[] = {
5159 (char *) "self",(char *) "h", NULL
5160 };
5161
5162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5164 if (SWIG_arg_fail(1)) SWIG_fail;
5165 {
5166 arg2 = (int)(SWIG_As_int(obj1));
5167 if (SWIG_arg_fail(2)) SWIG_fail;
5168 }
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 (arg1)->SetHeight(arg2);
5172
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 Py_INCREF(Py_None); resultobj = Py_None;
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj;
5185 wxRect *arg1 = (wxRect *) 0 ;
5186 wxPoint result;
5187 PyObject * obj0 = 0 ;
5188 char *kwnames[] = {
5189 (char *) "self", NULL
5190 };
5191
5192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5194 if (SWIG_arg_fail(1)) SWIG_fail;
5195 {
5196 PyThreadState* __tstate = wxPyBeginAllowThreads();
5197 result = ((wxRect const *)arg1)->GetPosition();
5198
5199 wxPyEndAllowThreads(__tstate);
5200 if (PyErr_Occurred()) SWIG_fail;
5201 }
5202 {
5203 wxPoint * resultptr;
5204 resultptr = new wxPoint((wxPoint &)(result));
5205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5206 }
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj;
5215 wxRect *arg1 = (wxRect *) 0 ;
5216 wxPoint *arg2 = 0 ;
5217 wxPoint temp2 ;
5218 PyObject * obj0 = 0 ;
5219 PyObject * obj1 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self",(char *) "p", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 arg2 = &temp2;
5229 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5230 }
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 (arg1)->SetPosition((wxPoint const &)*arg2);
5234
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 Py_INCREF(Py_None); resultobj = Py_None;
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj;
5247 wxRect *arg1 = (wxRect *) 0 ;
5248 wxSize result;
5249 PyObject * obj0 = 0 ;
5250 char *kwnames[] = {
5251 (char *) "self", NULL
5252 };
5253
5254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5256 if (SWIG_arg_fail(1)) SWIG_fail;
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = ((wxRect const *)arg1)->GetSize();
5260
5261 wxPyEndAllowThreads(__tstate);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 {
5265 wxSize * resultptr;
5266 resultptr = new wxSize((wxSize &)(result));
5267 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5268 }
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj;
5277 wxRect *arg1 = (wxRect *) 0 ;
5278 wxSize *arg2 = 0 ;
5279 wxSize temp2 ;
5280 PyObject * obj0 = 0 ;
5281 PyObject * obj1 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "self",(char *) "s", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5288 if (SWIG_arg_fail(1)) SWIG_fail;
5289 {
5290 arg2 = &temp2;
5291 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5292 }
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 (arg1)->SetSize((wxSize const &)*arg2);
5296
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 Py_INCREF(Py_None); resultobj = Py_None;
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj;
5309 wxRect *arg1 = (wxRect *) 0 ;
5310 bool result;
5311 PyObject * obj0 = 0 ;
5312 char *kwnames[] = {
5313 (char *) "self", NULL
5314 };
5315
5316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5318 if (SWIG_arg_fail(1)) SWIG_fail;
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 result = (bool)((wxRect const *)arg1)->IsEmpty();
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 {
5327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5328 }
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5336 PyObject *resultobj;
5337 wxRect *arg1 = (wxRect *) 0 ;
5338 wxPoint result;
5339 PyObject * obj0 = 0 ;
5340 char *kwnames[] = {
5341 (char *) "self", NULL
5342 };
5343
5344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(1)) SWIG_fail;
5347 {
5348 PyThreadState* __tstate = wxPyBeginAllowThreads();
5349 result = ((wxRect const *)arg1)->GetTopLeft();
5350
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 wxPoint * resultptr;
5356 resultptr = new wxPoint((wxPoint &)(result));
5357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5366 PyObject *resultobj;
5367 wxRect *arg1 = (wxRect *) 0 ;
5368 wxPoint *arg2 = 0 ;
5369 wxPoint temp2 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char *kwnames[] = {
5373 (char *) "self",(char *) "p", NULL
5374 };
5375
5376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5378 if (SWIG_arg_fail(1)) SWIG_fail;
5379 {
5380 arg2 = &temp2;
5381 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5382 }
5383 {
5384 PyThreadState* __tstate = wxPyBeginAllowThreads();
5385 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5386
5387 wxPyEndAllowThreads(__tstate);
5388 if (PyErr_Occurred()) SWIG_fail;
5389 }
5390 Py_INCREF(Py_None); resultobj = Py_None;
5391 return resultobj;
5392 fail:
5393 return NULL;
5394 }
5395
5396
5397 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5398 PyObject *resultobj;
5399 wxRect *arg1 = (wxRect *) 0 ;
5400 wxPoint result;
5401 PyObject * obj0 = 0 ;
5402 char *kwnames[] = {
5403 (char *) "self", NULL
5404 };
5405
5406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5408 if (SWIG_arg_fail(1)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = ((wxRect const *)arg1)->GetBottomRight();
5412
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 wxPoint * resultptr;
5418 resultptr = new wxPoint((wxPoint &)(result));
5419 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5420 }
5421 return resultobj;
5422 fail:
5423 return NULL;
5424 }
5425
5426
5427 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5428 PyObject *resultobj;
5429 wxRect *arg1 = (wxRect *) 0 ;
5430 wxPoint *arg2 = 0 ;
5431 wxPoint temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char *kwnames[] = {
5435 (char *) "self",(char *) "p", NULL
5436 };
5437
5438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5440 if (SWIG_arg_fail(1)) SWIG_fail;
5441 {
5442 arg2 = &temp2;
5443 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5444 }
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5448
5449 wxPyEndAllowThreads(__tstate);
5450 if (PyErr_Occurred()) SWIG_fail;
5451 }
5452 Py_INCREF(Py_None); resultobj = Py_None;
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5460 PyObject *resultobj;
5461 wxRect *arg1 = (wxRect *) 0 ;
5462 int result;
5463 PyObject * obj0 = 0 ;
5464 char *kwnames[] = {
5465 (char *) "self", NULL
5466 };
5467
5468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5470 if (SWIG_arg_fail(1)) SWIG_fail;
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 result = (int)((wxRect const *)arg1)->GetLeft();
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 {
5479 resultobj = SWIG_From_int((int)(result));
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 wxRect *arg1 = (wxRect *) 0 ;
5490 int result;
5491 PyObject * obj0 = 0 ;
5492 char *kwnames[] = {
5493 (char *) "self", NULL
5494 };
5495
5496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5498 if (SWIG_arg_fail(1)) SWIG_fail;
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (int)((wxRect const *)arg1)->GetTop();
5502
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 {
5507 resultobj = SWIG_From_int((int)(result));
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxRect *arg1 = (wxRect *) 0 ;
5518 int result;
5519 PyObject * obj0 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 PyThreadState* __tstate = wxPyBeginAllowThreads();
5529 result = (int)((wxRect const *)arg1)->GetBottom();
5530
5531 wxPyEndAllowThreads(__tstate);
5532 if (PyErr_Occurred()) SWIG_fail;
5533 }
5534 {
5535 resultobj = SWIG_From_int((int)(result));
5536 }
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5544 PyObject *resultobj;
5545 wxRect *arg1 = (wxRect *) 0 ;
5546 int result;
5547 PyObject * obj0 = 0 ;
5548 char *kwnames[] = {
5549 (char *) "self", NULL
5550 };
5551
5552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5554 if (SWIG_arg_fail(1)) SWIG_fail;
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = (int)((wxRect const *)arg1)->GetRight();
5558
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 {
5563 resultobj = SWIG_From_int((int)(result));
5564 }
5565 return resultobj;
5566 fail:
5567 return NULL;
5568 }
5569
5570
5571 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj;
5573 wxRect *arg1 = (wxRect *) 0 ;
5574 int arg2 ;
5575 PyObject * obj0 = 0 ;
5576 PyObject * obj1 = 0 ;
5577 char *kwnames[] = {
5578 (char *) "self",(char *) "left", NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5583 if (SWIG_arg_fail(1)) SWIG_fail;
5584 {
5585 arg2 = (int)(SWIG_As_int(obj1));
5586 if (SWIG_arg_fail(2)) SWIG_fail;
5587 }
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 (arg1)->SetLeft(arg2);
5591
5592 wxPyEndAllowThreads(__tstate);
5593 if (PyErr_Occurred()) SWIG_fail;
5594 }
5595 Py_INCREF(Py_None); resultobj = Py_None;
5596 return resultobj;
5597 fail:
5598 return NULL;
5599 }
5600
5601
5602 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5603 PyObject *resultobj;
5604 wxRect *arg1 = (wxRect *) 0 ;
5605 int arg2 ;
5606 PyObject * obj0 = 0 ;
5607 PyObject * obj1 = 0 ;
5608 char *kwnames[] = {
5609 (char *) "self",(char *) "right", NULL
5610 };
5611
5612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5614 if (SWIG_arg_fail(1)) SWIG_fail;
5615 {
5616 arg2 = (int)(SWIG_As_int(obj1));
5617 if (SWIG_arg_fail(2)) SWIG_fail;
5618 }
5619 {
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 (arg1)->SetRight(arg2);
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 Py_INCREF(Py_None); resultobj = Py_None;
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 wxRect *arg1 = (wxRect *) 0 ;
5636 int arg2 ;
5637 PyObject * obj0 = 0 ;
5638 PyObject * obj1 = 0 ;
5639 char *kwnames[] = {
5640 (char *) "self",(char *) "top", NULL
5641 };
5642
5643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5645 if (SWIG_arg_fail(1)) SWIG_fail;
5646 {
5647 arg2 = (int)(SWIG_As_int(obj1));
5648 if (SWIG_arg_fail(2)) SWIG_fail;
5649 }
5650 {
5651 PyThreadState* __tstate = wxPyBeginAllowThreads();
5652 (arg1)->SetTop(arg2);
5653
5654 wxPyEndAllowThreads(__tstate);
5655 if (PyErr_Occurred()) SWIG_fail;
5656 }
5657 Py_INCREF(Py_None); resultobj = Py_None;
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
5664 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj;
5666 wxRect *arg1 = (wxRect *) 0 ;
5667 int arg2 ;
5668 PyObject * obj0 = 0 ;
5669 PyObject * obj1 = 0 ;
5670 char *kwnames[] = {
5671 (char *) "self",(char *) "bottom", NULL
5672 };
5673
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5676 if (SWIG_arg_fail(1)) SWIG_fail;
5677 {
5678 arg2 = (int)(SWIG_As_int(obj1));
5679 if (SWIG_arg_fail(2)) SWIG_fail;
5680 }
5681 {
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 (arg1)->SetBottom(arg2);
5684
5685 wxPyEndAllowThreads(__tstate);
5686 if (PyErr_Occurred()) SWIG_fail;
5687 }
5688 Py_INCREF(Py_None); resultobj = Py_None;
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj;
5697 wxRect *arg1 = (wxRect *) 0 ;
5698 int arg2 ;
5699 int arg3 ;
5700 wxRect *result;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 PyObject * obj2 = 0 ;
5704 char *kwnames[] = {
5705 (char *) "self",(char *) "dx",(char *) "dy", NULL
5706 };
5707
5708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5710 if (SWIG_arg_fail(1)) SWIG_fail;
5711 {
5712 arg2 = (int)(SWIG_As_int(obj1));
5713 if (SWIG_arg_fail(2)) SWIG_fail;
5714 }
5715 {
5716 arg3 = (int)(SWIG_As_int(obj2));
5717 if (SWIG_arg_fail(3)) SWIG_fail;
5718 }
5719 {
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 {
5722 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5723 result = (wxRect *) &_result_ref;
5724 }
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj;
5738 wxRect *arg1 = (wxRect *) 0 ;
5739 int arg2 ;
5740 int arg3 ;
5741 wxRect *result;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 PyObject * obj2 = 0 ;
5745 char *kwnames[] = {
5746 (char *) "self",(char *) "dx",(char *) "dy", NULL
5747 };
5748
5749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5751 if (SWIG_arg_fail(1)) SWIG_fail;
5752 {
5753 arg2 = (int)(SWIG_As_int(obj1));
5754 if (SWIG_arg_fail(2)) SWIG_fail;
5755 }
5756 {
5757 arg3 = (int)(SWIG_As_int(obj2));
5758 if (SWIG_arg_fail(3)) SWIG_fail;
5759 }
5760 {
5761 PyThreadState* __tstate = wxPyBeginAllowThreads();
5762 {
5763 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5764 result = (wxRect *) &_result_ref;
5765 }
5766
5767 wxPyEndAllowThreads(__tstate);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj;
5779 wxRect *arg1 = (wxRect *) 0 ;
5780 int arg2 ;
5781 int arg3 ;
5782 PyObject * obj0 = 0 ;
5783 PyObject * obj1 = 0 ;
5784 PyObject * obj2 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "self",(char *) "dx",(char *) "dy", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5791 if (SWIG_arg_fail(1)) SWIG_fail;
5792 {
5793 arg2 = (int)(SWIG_As_int(obj1));
5794 if (SWIG_arg_fail(2)) SWIG_fail;
5795 }
5796 {
5797 arg3 = (int)(SWIG_As_int(obj2));
5798 if (SWIG_arg_fail(3)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 (arg1)->Offset(arg2,arg3);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 Py_INCREF(Py_None); resultobj = Py_None;
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj;
5816 wxRect *arg1 = (wxRect *) 0 ;
5817 wxPoint *arg2 = 0 ;
5818 wxPoint temp2 ;
5819 PyObject * obj0 = 0 ;
5820 PyObject * obj1 = 0 ;
5821 char *kwnames[] = {
5822 (char *) "self",(char *) "pt", NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5827 if (SWIG_arg_fail(1)) SWIG_fail;
5828 {
5829 arg2 = &temp2;
5830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5831 }
5832 {
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 (arg1)->Offset((wxPoint const &)*arg2);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxRect *arg1 = (wxRect *) 0 ;
5849 wxRect *arg2 = 0 ;
5850 wxRect result;
5851 wxRect temp2 ;
5852 PyObject * obj0 = 0 ;
5853 PyObject * obj1 = 0 ;
5854 char *kwnames[] = {
5855 (char *) "self",(char *) "rect", NULL
5856 };
5857
5858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 {
5862 arg2 = &temp2;
5863 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5864 }
5865 {
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 result = (arg1)->Intersect((wxRect const &)*arg2);
5868
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 {
5873 wxRect * resultptr;
5874 resultptr = new wxRect((wxRect &)(result));
5875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5876 }
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj;
5885 wxRect *arg1 = (wxRect *) 0 ;
5886 wxRect *arg2 = 0 ;
5887 wxRect result;
5888 wxRect temp2 ;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "self",(char *) "rect", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5897 if (SWIG_arg_fail(1)) SWIG_fail;
5898 {
5899 arg2 = &temp2;
5900 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5901 }
5902 {
5903 PyThreadState* __tstate = wxPyBeginAllowThreads();
5904 result = (arg1)->Union((wxRect const &)*arg2);
5905
5906 wxPyEndAllowThreads(__tstate);
5907 if (PyErr_Occurred()) SWIG_fail;
5908 }
5909 {
5910 wxRect * resultptr;
5911 resultptr = new wxRect((wxRect &)(result));
5912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5913 }
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj;
5922 wxRect *arg1 = (wxRect *) 0 ;
5923 wxRect *arg2 = 0 ;
5924 wxRect result;
5925 wxRect temp2 ;
5926 PyObject * obj0 = 0 ;
5927 PyObject * obj1 = 0 ;
5928 char *kwnames[] = {
5929 (char *) "self",(char *) "rect", NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5934 if (SWIG_arg_fail(1)) SWIG_fail;
5935 {
5936 arg2 = &temp2;
5937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5938 }
5939 {
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 {
5947 wxRect * resultptr;
5948 resultptr = new wxRect((wxRect &)(result));
5949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5950 }
5951 return resultobj;
5952 fail:
5953 return NULL;
5954 }
5955
5956
5957 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj;
5959 wxRect *arg1 = (wxRect *) 0 ;
5960 wxRect *arg2 = 0 ;
5961 wxRect *result;
5962 wxRect temp2 ;
5963 PyObject * obj0 = 0 ;
5964 PyObject * obj1 = 0 ;
5965 char *kwnames[] = {
5966 (char *) "self",(char *) "rect", NULL
5967 };
5968
5969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5971 if (SWIG_arg_fail(1)) SWIG_fail;
5972 {
5973 arg2 = &temp2;
5974 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5975 }
5976 {
5977 PyThreadState* __tstate = wxPyBeginAllowThreads();
5978 {
5979 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5980 result = (wxRect *) &_result_ref;
5981 }
5982
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5987 return resultobj;
5988 fail:
5989 return NULL;
5990 }
5991
5992
5993 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5994 PyObject *resultobj;
5995 wxRect *arg1 = (wxRect *) 0 ;
5996 wxRect *arg2 = 0 ;
5997 bool result;
5998 wxRect temp2 ;
5999 PyObject * obj0 = 0 ;
6000 PyObject * obj1 = 0 ;
6001 char *kwnames[] = {
6002 (char *) "self",(char *) "rect", NULL
6003 };
6004
6005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6007 if (SWIG_arg_fail(1)) SWIG_fail;
6008 {
6009 arg2 = &temp2;
6010 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6011 }
6012 {
6013 PyThreadState* __tstate = wxPyBeginAllowThreads();
6014 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6015
6016 wxPyEndAllowThreads(__tstate);
6017 if (PyErr_Occurred()) SWIG_fail;
6018 }
6019 {
6020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6021 }
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj;
6030 wxRect *arg1 = (wxRect *) 0 ;
6031 wxRect *arg2 = 0 ;
6032 bool result;
6033 wxRect temp2 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 char *kwnames[] = {
6037 (char *) "self",(char *) "rect", NULL
6038 };
6039
6040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6042 if (SWIG_arg_fail(1)) SWIG_fail;
6043 {
6044 arg2 = &temp2;
6045 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6046 }
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6056 }
6057 return resultobj;
6058 fail:
6059 return NULL;
6060 }
6061
6062
6063 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj;
6065 wxRect *arg1 = (wxRect *) 0 ;
6066 int arg2 ;
6067 int arg3 ;
6068 bool result;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 PyObject * obj2 = 0 ;
6072 char *kwnames[] = {
6073 (char *) "self",(char *) "x",(char *) "y", NULL
6074 };
6075
6076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6078 if (SWIG_arg_fail(1)) SWIG_fail;
6079 {
6080 arg2 = (int)(SWIG_As_int(obj1));
6081 if (SWIG_arg_fail(2)) SWIG_fail;
6082 }
6083 {
6084 arg3 = (int)(SWIG_As_int(obj2));
6085 if (SWIG_arg_fail(3)) SWIG_fail;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6090
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 {
6095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6096 }
6097 return resultobj;
6098 fail:
6099 return NULL;
6100 }
6101
6102
6103 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6104 PyObject *resultobj;
6105 wxRect *arg1 = (wxRect *) 0 ;
6106 wxPoint *arg2 = 0 ;
6107 bool result;
6108 wxPoint temp2 ;
6109 PyObject * obj0 = 0 ;
6110 PyObject * obj1 = 0 ;
6111 char *kwnames[] = {
6112 (char *) "self",(char *) "pt", NULL
6113 };
6114
6115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6117 if (SWIG_arg_fail(1)) SWIG_fail;
6118 {
6119 arg2 = &temp2;
6120 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6121 }
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 {
6130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6131 }
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj;
6140 wxRect *arg1 = (wxRect *) 0 ;
6141 wxRect *arg2 = 0 ;
6142 bool result;
6143 wxRect temp2 ;
6144 PyObject * obj0 = 0 ;
6145 PyObject * obj1 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "self",(char *) "rect", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6152 if (SWIG_arg_fail(1)) SWIG_fail;
6153 {
6154 arg2 = &temp2;
6155 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6156 }
6157 {
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 {
6165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6166 }
6167 return resultobj;
6168 fail:
6169 return NULL;
6170 }
6171
6172
6173 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6174 PyObject *resultobj;
6175 wxRect *arg1 = (wxRect *) 0 ;
6176 int arg2 ;
6177 PyObject * obj0 = 0 ;
6178 PyObject * obj1 = 0 ;
6179 char *kwnames[] = {
6180 (char *) "self",(char *) "x", NULL
6181 };
6182
6183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6185 if (SWIG_arg_fail(1)) SWIG_fail;
6186 {
6187 arg2 = (int)(SWIG_As_int(obj1));
6188 if (SWIG_arg_fail(2)) SWIG_fail;
6189 }
6190 if (arg1) (arg1)->x = arg2;
6191
6192 Py_INCREF(Py_None); resultobj = Py_None;
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj;
6201 wxRect *arg1 = (wxRect *) 0 ;
6202 int result;
6203 PyObject * obj0 = 0 ;
6204 char *kwnames[] = {
6205 (char *) "self", NULL
6206 };
6207
6208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6210 if (SWIG_arg_fail(1)) SWIG_fail;
6211 result = (int) ((arg1)->x);
6212
6213 {
6214 resultobj = SWIG_From_int((int)(result));
6215 }
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj;
6224 wxRect *arg1 = (wxRect *) 0 ;
6225 int arg2 ;
6226 PyObject * obj0 = 0 ;
6227 PyObject * obj1 = 0 ;
6228 char *kwnames[] = {
6229 (char *) "self",(char *) "y", NULL
6230 };
6231
6232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6234 if (SWIG_arg_fail(1)) SWIG_fail;
6235 {
6236 arg2 = (int)(SWIG_As_int(obj1));
6237 if (SWIG_arg_fail(2)) SWIG_fail;
6238 }
6239 if (arg1) (arg1)->y = arg2;
6240
6241 Py_INCREF(Py_None); resultobj = Py_None;
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj;
6250 wxRect *arg1 = (wxRect *) 0 ;
6251 int result;
6252 PyObject * obj0 = 0 ;
6253 char *kwnames[] = {
6254 (char *) "self", NULL
6255 };
6256
6257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6259 if (SWIG_arg_fail(1)) SWIG_fail;
6260 result = (int) ((arg1)->y);
6261
6262 {
6263 resultobj = SWIG_From_int((int)(result));
6264 }
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 wxRect *arg1 = (wxRect *) 0 ;
6274 int arg2 ;
6275 PyObject * obj0 = 0 ;
6276 PyObject * obj1 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self",(char *) "width", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 {
6285 arg2 = (int)(SWIG_As_int(obj1));
6286 if (SWIG_arg_fail(2)) SWIG_fail;
6287 }
6288 if (arg1) (arg1)->width = arg2;
6289
6290 Py_INCREF(Py_None); resultobj = Py_None;
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj;
6299 wxRect *arg1 = (wxRect *) 0 ;
6300 int result;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "self", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 result = (int) ((arg1)->width);
6310
6311 {
6312 resultobj = SWIG_From_int((int)(result));
6313 }
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj;
6322 wxRect *arg1 = (wxRect *) 0 ;
6323 int arg2 ;
6324 PyObject * obj0 = 0 ;
6325 PyObject * obj1 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self",(char *) "height", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 {
6334 arg2 = (int)(SWIG_As_int(obj1));
6335 if (SWIG_arg_fail(2)) SWIG_fail;
6336 }
6337 if (arg1) (arg1)->height = arg2;
6338
6339 Py_INCREF(Py_None); resultobj = Py_None;
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6347 PyObject *resultobj;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 int result;
6350 PyObject * obj0 = 0 ;
6351 char *kwnames[] = {
6352 (char *) "self", NULL
6353 };
6354
6355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 result = (int) ((arg1)->height);
6359
6360 {
6361 resultobj = SWIG_From_int((int)(result));
6362 }
6363 return resultobj;
6364 fail:
6365 return NULL;
6366 }
6367
6368
6369 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6370 PyObject *resultobj;
6371 wxRect *arg1 = (wxRect *) 0 ;
6372 int arg2 = (int) 0 ;
6373 int arg3 = (int) 0 ;
6374 int arg4 = (int) 0 ;
6375 int arg5 = (int) 0 ;
6376 PyObject * obj0 = 0 ;
6377 PyObject * obj1 = 0 ;
6378 PyObject * obj2 = 0 ;
6379 PyObject * obj3 = 0 ;
6380 PyObject * obj4 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 if (obj1) {
6389 {
6390 arg2 = (int)(SWIG_As_int(obj1));
6391 if (SWIG_arg_fail(2)) SWIG_fail;
6392 }
6393 }
6394 if (obj2) {
6395 {
6396 arg3 = (int)(SWIG_As_int(obj2));
6397 if (SWIG_arg_fail(3)) SWIG_fail;
6398 }
6399 }
6400 if (obj3) {
6401 {
6402 arg4 = (int)(SWIG_As_int(obj3));
6403 if (SWIG_arg_fail(4)) SWIG_fail;
6404 }
6405 }
6406 if (obj4) {
6407 {
6408 arg5 = (int)(SWIG_As_int(obj4));
6409 if (SWIG_arg_fail(5)) SWIG_fail;
6410 }
6411 }
6412 {
6413 PyThreadState* __tstate = wxPyBeginAllowThreads();
6414 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6415
6416 wxPyEndAllowThreads(__tstate);
6417 if (PyErr_Occurred()) SWIG_fail;
6418 }
6419 Py_INCREF(Py_None); resultobj = Py_None;
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj;
6428 wxRect *arg1 = (wxRect *) 0 ;
6429 PyObject *result;
6430 PyObject * obj0 = 0 ;
6431 char *kwnames[] = {
6432 (char *) "self", NULL
6433 };
6434
6435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6437 if (SWIG_arg_fail(1)) SWIG_fail;
6438 {
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (PyObject *)wxRect_Get(arg1);
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = result;
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6453 PyObject *obj;
6454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6455 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6456 Py_INCREF(obj);
6457 return Py_BuildValue((char *)"");
6458 }
6459 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 wxRect *arg2 = (wxRect *) 0 ;
6463 PyObject *result;
6464 PyObject * obj0 = 0 ;
6465 PyObject * obj1 = 0 ;
6466 char *kwnames[] = {
6467 (char *) "r1",(char *) "r2", NULL
6468 };
6469
6470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6472 if (SWIG_arg_fail(1)) SWIG_fail;
6473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6474 if (SWIG_arg_fail(2)) SWIG_fail;
6475 {
6476 if (!wxPyCheckForApp()) SWIG_fail;
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (PyObject *)wxIntersectRect(arg1,arg2);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = result;
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 double arg1 = (double) 0.0 ;
6493 double arg2 = (double) 0.0 ;
6494 wxPoint2D *result;
6495 PyObject * obj0 = 0 ;
6496 PyObject * obj1 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "x",(char *) "y", NULL
6499 };
6500
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6502 if (obj0) {
6503 {
6504 arg1 = (double)(SWIG_As_double(obj0));
6505 if (SWIG_arg_fail(1)) SWIG_fail;
6506 }
6507 }
6508 if (obj1) {
6509 {
6510 arg2 = (double)(SWIG_As_double(obj1));
6511 if (SWIG_arg_fail(2)) SWIG_fail;
6512 }
6513 }
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6517
6518 wxPyEndAllowThreads(__tstate);
6519 if (PyErr_Occurred()) SWIG_fail;
6520 }
6521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6522 return resultobj;
6523 fail:
6524 return NULL;
6525 }
6526
6527
6528 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6529 PyObject *resultobj;
6530 wxPoint2D *arg1 = 0 ;
6531 wxPoint2D *result;
6532 wxPoint2D temp1 ;
6533 PyObject * obj0 = 0 ;
6534 char *kwnames[] = {
6535 (char *) "pt", NULL
6536 };
6537
6538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6539 {
6540 arg1 = &temp1;
6541 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6542 }
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6546
6547 wxPyEndAllowThreads(__tstate);
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj;
6559 wxPoint *arg1 = 0 ;
6560 wxPoint2D *result;
6561 wxPoint temp1 ;
6562 PyObject * obj0 = 0 ;
6563 char *kwnames[] = {
6564 (char *) "pt", NULL
6565 };
6566
6567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6568 {
6569 arg1 = &temp1;
6570 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6571 }
6572 {
6573 PyThreadState* __tstate = wxPyBeginAllowThreads();
6574 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6575
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6587 PyObject *resultobj;
6588 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6589 int *arg2 = (int *) 0 ;
6590 int *arg3 = (int *) 0 ;
6591 int temp2 ;
6592 int res2 = 0 ;
6593 int temp3 ;
6594 int res3 = 0 ;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6601 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6604 if (SWIG_arg_fail(1)) SWIG_fail;
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 Py_INCREF(Py_None); resultobj = Py_None;
6613 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6614 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6615 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6616 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj;
6625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6626 int *arg2 = (int *) 0 ;
6627 int *arg3 = (int *) 0 ;
6628 int temp2 ;
6629 int res2 = 0 ;
6630 int temp3 ;
6631 int res3 = 0 ;
6632 PyObject * obj0 = 0 ;
6633 char *kwnames[] = {
6634 (char *) "self", NULL
6635 };
6636
6637 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6638 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6641 if (SWIG_arg_fail(1)) SWIG_fail;
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6645
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 Py_INCREF(Py_None); resultobj = Py_None;
6650 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6651 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6652 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6653 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj;
6662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6663 double result;
6664 PyObject * obj0 = 0 ;
6665 char *kwnames[] = {
6666 (char *) "self", NULL
6667 };
6668
6669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6671 if (SWIG_arg_fail(1)) SWIG_fail;
6672 {
6673 PyThreadState* __tstate = wxPyBeginAllowThreads();
6674 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6675
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 {
6680 resultobj = SWIG_From_double((double)(result));
6681 }
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6689 PyObject *resultobj;
6690 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6691 double result;
6692 PyObject * obj0 = 0 ;
6693 char *kwnames[] = {
6694 (char *) "self", NULL
6695 };
6696
6697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6699 if (SWIG_arg_fail(1)) SWIG_fail;
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6703
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 {
6708 resultobj = SWIG_From_double((double)(result));
6709 }
6710 return resultobj;
6711 fail:
6712 return NULL;
6713 }
6714
6715
6716 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6717 PyObject *resultobj;
6718 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6719 double arg2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char *kwnames[] = {
6723 (char *) "self",(char *) "length", NULL
6724 };
6725
6726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6728 if (SWIG_arg_fail(1)) SWIG_fail;
6729 {
6730 arg2 = (double)(SWIG_As_double(obj1));
6731 if (SWIG_arg_fail(2)) SWIG_fail;
6732 }
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 (arg1)->SetVectorLength(arg2);
6736
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 Py_INCREF(Py_None); resultobj = Py_None;
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6748 PyObject *resultobj;
6749 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6750 double arg2 ;
6751 PyObject * obj0 = 0 ;
6752 PyObject * obj1 = 0 ;
6753 char *kwnames[] = {
6754 (char *) "self",(char *) "degrees", NULL
6755 };
6756
6757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6759 if (SWIG_arg_fail(1)) SWIG_fail;
6760 {
6761 arg2 = (double)(SWIG_As_double(obj1));
6762 if (SWIG_arg_fail(2)) SWIG_fail;
6763 }
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 (arg1)->SetVectorAngle(arg2);
6767
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 Py_INCREF(Py_None); resultobj = Py_None;
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6779 PyObject *resultobj;
6780 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6781 wxPoint2D *arg2 = 0 ;
6782 double result;
6783 wxPoint2D temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char *kwnames[] = {
6787 (char *) "self",(char *) "pt", NULL
6788 };
6789
6790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6792 if (SWIG_arg_fail(1)) SWIG_fail;
6793 {
6794 arg2 = &temp2;
6795 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6796 }
6797 {
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6800
6801 wxPyEndAllowThreads(__tstate);
6802 if (PyErr_Occurred()) SWIG_fail;
6803 }
6804 {
6805 resultobj = SWIG_From_double((double)(result));
6806 }
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6816 wxPoint2D *arg2 = 0 ;
6817 double result;
6818 wxPoint2D temp2 ;
6819 PyObject * obj0 = 0 ;
6820 PyObject * obj1 = 0 ;
6821 char *kwnames[] = {
6822 (char *) "self",(char *) "pt", NULL
6823 };
6824
6825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6827 if (SWIG_arg_fail(1)) SWIG_fail;
6828 {
6829 arg2 = &temp2;
6830 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6831 }
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = SWIG_From_double((double)(result));
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6851 wxPoint2D *arg2 = 0 ;
6852 double result;
6853 wxPoint2D temp2 ;
6854 PyObject * obj0 = 0 ;
6855 PyObject * obj1 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self",(char *) "vec", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 arg2 = &temp2;
6865 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6866 }
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 {
6875 resultobj = SWIG_From_double((double)(result));
6876 }
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj;
6885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6886 wxPoint2D *arg2 = 0 ;
6887 double result;
6888 wxPoint2D temp2 ;
6889 PyObject * obj0 = 0 ;
6890 PyObject * obj1 = 0 ;
6891 char *kwnames[] = {
6892 (char *) "self",(char *) "vec", NULL
6893 };
6894
6895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6897 if (SWIG_arg_fail(1)) SWIG_fail;
6898 {
6899 arg2 = &temp2;
6900 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6901 }
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 {
6910 resultobj = SWIG_From_double((double)(result));
6911 }
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6919 PyObject *resultobj;
6920 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6921 wxPoint2D result;
6922 PyObject * obj0 = 0 ;
6923 char *kwnames[] = {
6924 (char *) "self", NULL
6925 };
6926
6927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6929 if (SWIG_arg_fail(1)) SWIG_fail;
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = (arg1)->operator -();
6933
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 {
6938 wxPoint2D * resultptr;
6939 resultptr = new wxPoint2D((wxPoint2D &)(result));
6940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6941 }
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj;
6950 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6951 wxPoint2D *arg2 = 0 ;
6952 wxPoint2D *result;
6953 wxPoint2D temp2 ;
6954 PyObject * obj0 = 0 ;
6955 PyObject * obj1 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self",(char *) "pt", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 arg2 = &temp2;
6965 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6966 }
6967 {
6968 PyThreadState* __tstate = wxPyBeginAllowThreads();
6969 {
6970 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6971 result = (wxPoint2D *) &_result_ref;
6972 }
6973
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj;
6986 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6987 wxPoint2D *arg2 = 0 ;
6988 wxPoint2D *result;
6989 wxPoint2D temp2 ;
6990 PyObject * obj0 = 0 ;
6991 PyObject * obj1 = 0 ;
6992 char *kwnames[] = {
6993 (char *) "self",(char *) "pt", NULL
6994 };
6995
6996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6998 if (SWIG_arg_fail(1)) SWIG_fail;
6999 {
7000 arg2 = &temp2;
7001 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7002 }
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 {
7006 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7007 result = (wxPoint2D *) &_result_ref;
7008 }
7009
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj;
7022 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7023 wxPoint2D *arg2 = 0 ;
7024 wxPoint2D *result;
7025 wxPoint2D temp2 ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self",(char *) "pt", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 arg2 = &temp2;
7037 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7038 }
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 {
7042 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7043 result = (wxPoint2D *) &_result_ref;
7044 }
7045
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj;
7058 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7059 wxPoint2D *arg2 = 0 ;
7060 wxPoint2D *result;
7061 wxPoint2D temp2 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char *kwnames[] = {
7065 (char *) "self",(char *) "pt", NULL
7066 };
7067
7068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7070 if (SWIG_arg_fail(1)) SWIG_fail;
7071 {
7072 arg2 = &temp2;
7073 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7074 }
7075 {
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 {
7078 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7079 result = (wxPoint2D *) &_result_ref;
7080 }
7081
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj;
7094 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7095 wxPoint2D *arg2 = 0 ;
7096 bool result;
7097 wxPoint2D temp2 ;
7098 PyObject * obj0 = 0 ;
7099 PyObject * obj1 = 0 ;
7100 char *kwnames[] = {
7101 (char *) "self",(char *) "pt", NULL
7102 };
7103
7104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7106 if (SWIG_arg_fail(1)) SWIG_fail;
7107 {
7108 arg2 = &temp2;
7109 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7110 }
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7114
7115 wxPyEndAllowThreads(__tstate);
7116 if (PyErr_Occurred()) SWIG_fail;
7117 }
7118 {
7119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7120 }
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj;
7129 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7130 wxPoint2D *arg2 = 0 ;
7131 bool result;
7132 wxPoint2D temp2 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 char *kwnames[] = {
7136 (char *) "self",(char *) "pt", NULL
7137 };
7138
7139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7141 if (SWIG_arg_fail(1)) SWIG_fail;
7142 {
7143 arg2 = &temp2;
7144 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7145 }
7146 {
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7149
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 {
7154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7155 }
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj;
7164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7165 double arg2 ;
7166 PyObject * obj0 = 0 ;
7167 PyObject * obj1 = 0 ;
7168 char *kwnames[] = {
7169 (char *) "self",(char *) "m_x", NULL
7170 };
7171
7172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7174 if (SWIG_arg_fail(1)) SWIG_fail;
7175 {
7176 arg2 = (double)(SWIG_As_double(obj1));
7177 if (SWIG_arg_fail(2)) SWIG_fail;
7178 }
7179 if (arg1) (arg1)->m_x = arg2;
7180
7181 Py_INCREF(Py_None); resultobj = Py_None;
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj;
7190 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7191 double result;
7192 PyObject * obj0 = 0 ;
7193 char *kwnames[] = {
7194 (char *) "self", NULL
7195 };
7196
7197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7199 if (SWIG_arg_fail(1)) SWIG_fail;
7200 result = (double) ((arg1)->m_x);
7201
7202 {
7203 resultobj = SWIG_From_double((double)(result));
7204 }
7205 return resultobj;
7206 fail:
7207 return NULL;
7208 }
7209
7210
7211 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj;
7213 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7214 double arg2 ;
7215 PyObject * obj0 = 0 ;
7216 PyObject * obj1 = 0 ;
7217 char *kwnames[] = {
7218 (char *) "self",(char *) "m_y", NULL
7219 };
7220
7221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7223 if (SWIG_arg_fail(1)) SWIG_fail;
7224 {
7225 arg2 = (double)(SWIG_As_double(obj1));
7226 if (SWIG_arg_fail(2)) SWIG_fail;
7227 }
7228 if (arg1) (arg1)->m_y = arg2;
7229
7230 Py_INCREF(Py_None); resultobj = Py_None;
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj;
7239 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7240 double result;
7241 PyObject * obj0 = 0 ;
7242 char *kwnames[] = {
7243 (char *) "self", NULL
7244 };
7245
7246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7248 if (SWIG_arg_fail(1)) SWIG_fail;
7249 result = (double) ((arg1)->m_y);
7250
7251 {
7252 resultobj = SWIG_From_double((double)(result));
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj;
7262 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7263 double arg2 = (double) 0 ;
7264 double arg3 = (double) 0 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 PyObject * obj2 = 0 ;
7268 char *kwnames[] = {
7269 (char *) "self",(char *) "x",(char *) "y", NULL
7270 };
7271
7272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7274 if (SWIG_arg_fail(1)) SWIG_fail;
7275 if (obj1) {
7276 {
7277 arg2 = (double)(SWIG_As_double(obj1));
7278 if (SWIG_arg_fail(2)) SWIG_fail;
7279 }
7280 }
7281 if (obj2) {
7282 {
7283 arg3 = (double)(SWIG_As_double(obj2));
7284 if (SWIG_arg_fail(3)) SWIG_fail;
7285 }
7286 }
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 wxPoint2D_Set(arg1,arg2,arg3);
7290
7291 wxPyEndAllowThreads(__tstate);
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 Py_INCREF(Py_None); resultobj = Py_None;
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj;
7303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7304 PyObject *result;
7305 PyObject * obj0 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 {
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (PyObject *)wxPoint2D_Get(arg1);
7316
7317 wxPyEndAllowThreads(__tstate);
7318 if (PyErr_Occurred()) SWIG_fail;
7319 }
7320 resultobj = result;
7321 return resultobj;
7322 fail:
7323 return NULL;
7324 }
7325
7326
7327 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7328 PyObject *obj;
7329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7330 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7331 Py_INCREF(obj);
7332 return Py_BuildValue((char *)"");
7333 }
7334 static int _wrap_DefaultPosition_set(PyObject *) {
7335 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7336 return 1;
7337 }
7338
7339
7340 static PyObject *_wrap_DefaultPosition_get(void) {
7341 PyObject *pyobj;
7342
7343 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7344 return pyobj;
7345 }
7346
7347
7348 static int _wrap_DefaultSize_set(PyObject *) {
7349 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7350 return 1;
7351 }
7352
7353
7354 static PyObject *_wrap_DefaultSize_get(void) {
7355 PyObject *pyobj;
7356
7357 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7358 return pyobj;
7359 }
7360
7361
7362 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7363 PyObject *resultobj;
7364 PyObject *arg1 = (PyObject *) 0 ;
7365 wxPyInputStream *result;
7366 PyObject * obj0 = 0 ;
7367 char *kwnames[] = {
7368 (char *) "p", NULL
7369 };
7370
7371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7372 arg1 = obj0;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7397 if (SWIG_arg_fail(1)) SWIG_fail;
7398 {
7399 PyThreadState* __tstate = wxPyBeginAllowThreads();
7400 delete arg1;
7401
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 Py_INCREF(Py_None); resultobj = Py_None;
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj;
7414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7415 PyObject * obj0 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 (arg1)->close();
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 Py_INCREF(Py_None); resultobj = Py_None;
7431 return resultobj;
7432 fail:
7433 return NULL;
7434 }
7435
7436
7437 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7438 PyObject *resultobj;
7439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7440 PyObject * obj0 = 0 ;
7441 char *kwnames[] = {
7442 (char *) "self", NULL
7443 };
7444
7445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7447 if (SWIG_arg_fail(1)) SWIG_fail;
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 (arg1)->flush();
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7465 bool result;
7466 PyObject * obj0 = 0 ;
7467 char *kwnames[] = {
7468 (char *) "self", NULL
7469 };
7470
7471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7473 if (SWIG_arg_fail(1)) SWIG_fail;
7474 {
7475 PyThreadState* __tstate = wxPyBeginAllowThreads();
7476 result = (bool)(arg1)->eof();
7477
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj;
7492 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7493 int arg2 = (int) -1 ;
7494 PyObject *result;
7495 PyObject * obj0 = 0 ;
7496 PyObject * obj1 = 0 ;
7497 char *kwnames[] = {
7498 (char *) "self",(char *) "size", NULL
7499 };
7500
7501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7503 if (SWIG_arg_fail(1)) SWIG_fail;
7504 if (obj1) {
7505 {
7506 arg2 = (int)(SWIG_As_int(obj1));
7507 if (SWIG_arg_fail(2)) SWIG_fail;
7508 }
7509 }
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (PyObject *)(arg1)->read(arg2);
7513
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 resultobj = result;
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj;
7526 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7527 int arg2 = (int) -1 ;
7528 PyObject *result;
7529 PyObject * obj0 = 0 ;
7530 PyObject * obj1 = 0 ;
7531 char *kwnames[] = {
7532 (char *) "self",(char *) "size", NULL
7533 };
7534
7535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7537 if (SWIG_arg_fail(1)) SWIG_fail;
7538 if (obj1) {
7539 {
7540 arg2 = (int)(SWIG_As_int(obj1));
7541 if (SWIG_arg_fail(2)) SWIG_fail;
7542 }
7543 }
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 result = (PyObject *)(arg1)->readline(arg2);
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 resultobj = result;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj;
7560 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7561 int arg2 = (int) -1 ;
7562 PyObject *result;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char *kwnames[] = {
7566 (char *) "self",(char *) "sizehint", NULL
7567 };
7568
7569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7571 if (SWIG_arg_fail(1)) SWIG_fail;
7572 if (obj1) {
7573 {
7574 arg2 = (int)(SWIG_As_int(obj1));
7575 if (SWIG_arg_fail(2)) SWIG_fail;
7576 }
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = (PyObject *)(arg1)->readlines(arg2);
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = result;
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj;
7594 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7595 int arg2 ;
7596 int arg3 = (int) 0 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 PyObject * obj2 = 0 ;
7600 char *kwnames[] = {
7601 (char *) "self",(char *) "offset",(char *) "whence", NULL
7602 };
7603
7604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7606 if (SWIG_arg_fail(1)) SWIG_fail;
7607 {
7608 arg2 = (int)(SWIG_As_int(obj1));
7609 if (SWIG_arg_fail(2)) SWIG_fail;
7610 }
7611 if (obj2) {
7612 {
7613 arg3 = (int)(SWIG_As_int(obj2));
7614 if (SWIG_arg_fail(3)) SWIG_fail;
7615 }
7616 }
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 (arg1)->seek(arg2,arg3);
7620
7621 wxPyEndAllowThreads(__tstate);
7622 if (PyErr_Occurred()) SWIG_fail;
7623 }
7624 Py_INCREF(Py_None); resultobj = Py_None;
7625 return resultobj;
7626 fail:
7627 return NULL;
7628 }
7629
7630
7631 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7632 PyObject *resultobj;
7633 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7634 int result;
7635 PyObject * obj0 = 0 ;
7636 char *kwnames[] = {
7637 (char *) "self", NULL
7638 };
7639
7640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7642 if (SWIG_arg_fail(1)) SWIG_fail;
7643 {
7644 PyThreadState* __tstate = wxPyBeginAllowThreads();
7645 result = (int)(arg1)->tell();
7646
7647 wxPyEndAllowThreads(__tstate);
7648 if (PyErr_Occurred()) SWIG_fail;
7649 }
7650 {
7651 resultobj = SWIG_From_int((int)(result));
7652 }
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj;
7661 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7662 char result;
7663 PyObject * obj0 = 0 ;
7664 char *kwnames[] = {
7665 (char *) "self", NULL
7666 };
7667
7668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7670 if (SWIG_arg_fail(1)) SWIG_fail;
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (char)(arg1)->Peek();
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 {
7679 resultobj = SWIG_From_char((char)(result));
7680 }
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj;
7689 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7690 char result;
7691 PyObject * obj0 = 0 ;
7692 char *kwnames[] = {
7693 (char *) "self", NULL
7694 };
7695
7696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7698 if (SWIG_arg_fail(1)) SWIG_fail;
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 result = (char)(arg1)->GetC();
7702
7703 wxPyEndAllowThreads(__tstate);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 {
7707 resultobj = SWIG_From_char((char)(result));
7708 }
7709 return resultobj;
7710 fail:
7711 return NULL;
7712 }
7713
7714
7715 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7716 PyObject *resultobj;
7717 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7718 size_t result;
7719 PyObject * obj0 = 0 ;
7720 char *kwnames[] = {
7721 (char *) "self", NULL
7722 };
7723
7724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7726 if (SWIG_arg_fail(1)) SWIG_fail;
7727 {
7728 PyThreadState* __tstate = wxPyBeginAllowThreads();
7729 result = (size_t)(arg1)->LastRead();
7730
7731 wxPyEndAllowThreads(__tstate);
7732 if (PyErr_Occurred()) SWIG_fail;
7733 }
7734 {
7735 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7736 }
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj;
7745 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7746 bool result;
7747 PyObject * obj0 = 0 ;
7748 char *kwnames[] = {
7749 (char *) "self", NULL
7750 };
7751
7752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7754 if (SWIG_arg_fail(1)) SWIG_fail;
7755 {
7756 PyThreadState* __tstate = wxPyBeginAllowThreads();
7757 result = (bool)(arg1)->CanRead();
7758
7759 wxPyEndAllowThreads(__tstate);
7760 if (PyErr_Occurred()) SWIG_fail;
7761 }
7762 {
7763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7764 }
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7772 PyObject *resultobj;
7773 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7774 bool result;
7775 PyObject * obj0 = 0 ;
7776 char *kwnames[] = {
7777 (char *) "self", NULL
7778 };
7779
7780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7782 if (SWIG_arg_fail(1)) SWIG_fail;
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 result = (bool)(arg1)->Eof();
7786
7787 wxPyEndAllowThreads(__tstate);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 {
7791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7792 }
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj;
7801 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7802 char arg2 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 char *kwnames[] = {
7807 (char *) "self",(char *) "c", NULL
7808 };
7809
7810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7812 if (SWIG_arg_fail(1)) SWIG_fail;
7813 {
7814 arg2 = (char)(SWIG_As_char(obj1));
7815 if (SWIG_arg_fail(2)) SWIG_fail;
7816 }
7817 {
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 result = (bool)(arg1)->Ungetch(arg2);
7820
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 {
7825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7826 }
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj;
7835 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7836 long arg2 ;
7837 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7838 long result;
7839 PyObject * obj0 = 0 ;
7840 PyObject * obj1 = 0 ;
7841 PyObject * obj2 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self",(char *) "pos",(char *) "mode", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 arg2 = (long)(SWIG_As_long(obj1));
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 }
7853 if (obj2) {
7854 {
7855 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7856 if (SWIG_arg_fail(3)) SWIG_fail;
7857 }
7858 }
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 {
7867 resultobj = SWIG_From_long((long)(result));
7868 }
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7876 PyObject *resultobj;
7877 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7878 long result;
7879 PyObject * obj0 = 0 ;
7880 char *kwnames[] = {
7881 (char *) "self", NULL
7882 };
7883
7884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7886 if (SWIG_arg_fail(1)) SWIG_fail;
7887 {
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (long)(arg1)->TellI();
7890
7891 wxPyEndAllowThreads(__tstate);
7892 if (PyErr_Occurred()) SWIG_fail;
7893 }
7894 {
7895 resultobj = SWIG_From_long((long)(result));
7896 }
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7904 PyObject *obj;
7905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7906 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7907 Py_INCREF(obj);
7908 return Py_BuildValue((char *)"");
7909 }
7910 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj;
7912 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7913 PyObject *arg2 = (PyObject *) 0 ;
7914 PyObject * obj0 = 0 ;
7915 PyObject * obj1 = 0 ;
7916 char *kwnames[] = {
7917 (char *) "self",(char *) "obj", NULL
7918 };
7919
7920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7922 if (SWIG_arg_fail(1)) SWIG_fail;
7923 arg2 = obj1;
7924 {
7925 PyThreadState* __tstate = wxPyBeginAllowThreads();
7926 wxOutputStream_write(arg1,arg2);
7927
7928 wxPyEndAllowThreads(__tstate);
7929 if (PyErr_Occurred()) SWIG_fail;
7930 }
7931 Py_INCREF(Py_None); resultobj = Py_None;
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7939 PyObject *obj;
7940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7941 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7942 Py_INCREF(obj);
7943 return Py_BuildValue((char *)"");
7944 }
7945 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7946 PyObject *resultobj;
7947 wxInputStream *arg1 = (wxInputStream *) 0 ;
7948 wxString *arg2 = 0 ;
7949 wxString *arg3 = 0 ;
7950 wxString *arg4 = 0 ;
7951 wxDateTime arg5 ;
7952 wxFSFile *result;
7953 wxPyInputStream *temp1 ;
7954 bool temp2 = false ;
7955 bool temp3 = false ;
7956 bool temp4 = false ;
7957 PyObject * obj0 = 0 ;
7958 PyObject * obj1 = 0 ;
7959 PyObject * obj2 = 0 ;
7960 PyObject * obj3 = 0 ;
7961 PyObject * obj4 = 0 ;
7962 char *kwnames[] = {
7963 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7964 };
7965
7966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7967 {
7968 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7969 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7970 } else {
7971 PyErr_Clear(); // clear the failure of the wxPyConvert above
7972 arg1 = wxPyCBInputStream_create(obj0, true);
7973 if (arg1 == NULL) {
7974 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7975 SWIG_fail;
7976 }
7977 }
7978 }
7979 {
7980 arg2 = wxString_in_helper(obj1);
7981 if (arg2 == NULL) SWIG_fail;
7982 temp2 = true;
7983 }
7984 {
7985 arg3 = wxString_in_helper(obj2);
7986 if (arg3 == NULL) SWIG_fail;
7987 temp3 = true;
7988 }
7989 {
7990 arg4 = wxString_in_helper(obj3);
7991 if (arg4 == NULL) SWIG_fail;
7992 temp4 = true;
7993 }
7994 {
7995 wxDateTime * argp;
7996 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7997 if (SWIG_arg_fail(5)) SWIG_fail;
7998 if (argp == NULL) {
7999 SWIG_null_ref("wxDateTime");
8000 }
8001 if (SWIG_arg_fail(5)) SWIG_fail;
8002 arg5 = *argp;
8003 }
8004 {
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8007
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 {
8012 resultobj = wxPyMake_wxObject(result, 1);
8013 }
8014 {
8015 if (temp2)
8016 delete arg2;
8017 }
8018 {
8019 if (temp3)
8020 delete arg3;
8021 }
8022 {
8023 if (temp4)
8024 delete arg4;
8025 }
8026 return resultobj;
8027 fail:
8028 {
8029 if (temp2)
8030 delete arg2;
8031 }
8032 {
8033 if (temp3)
8034 delete arg3;
8035 }
8036 {
8037 if (temp4)
8038 delete arg4;
8039 }
8040 return NULL;
8041 }
8042
8043
8044 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8045 PyObject *resultobj;
8046 wxFSFile *arg1 = (wxFSFile *) 0 ;
8047 PyObject * obj0 = 0 ;
8048 char *kwnames[] = {
8049 (char *) "self", NULL
8050 };
8051
8052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8054 if (SWIG_arg_fail(1)) SWIG_fail;
8055 {
8056 PyThreadState* __tstate = wxPyBeginAllowThreads();
8057 delete arg1;
8058
8059 wxPyEndAllowThreads(__tstate);
8060 if (PyErr_Occurred()) SWIG_fail;
8061 }
8062 Py_INCREF(Py_None); resultobj = Py_None;
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8070 PyObject *resultobj;
8071 wxFSFile *arg1 = (wxFSFile *) 0 ;
8072 wxInputStream *result;
8073 PyObject * obj0 = 0 ;
8074 char *kwnames[] = {
8075 (char *) "self", NULL
8076 };
8077
8078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8080 if (SWIG_arg_fail(1)) SWIG_fail;
8081 {
8082 PyThreadState* __tstate = wxPyBeginAllowThreads();
8083 result = (wxInputStream *)(arg1)->GetStream();
8084
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 {
8089 wxPyInputStream * _ptr = NULL;
8090
8091 if (result) {
8092 _ptr = new wxPyInputStream(result);
8093 }
8094 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8095 }
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8103 PyObject *resultobj;
8104 wxFSFile *arg1 = (wxFSFile *) 0 ;
8105 wxString *result;
8106 PyObject * obj0 = 0 ;
8107 char *kwnames[] = {
8108 (char *) "self", NULL
8109 };
8110
8111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8113 if (SWIG_arg_fail(1)) SWIG_fail;
8114 {
8115 PyThreadState* __tstate = wxPyBeginAllowThreads();
8116 {
8117 wxString const &_result_ref = (arg1)->GetMimeType();
8118 result = (wxString *) &_result_ref;
8119 }
8120
8121 wxPyEndAllowThreads(__tstate);
8122 if (PyErr_Occurred()) SWIG_fail;
8123 }
8124 {
8125 #if wxUSE_UNICODE
8126 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8127 #else
8128 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8129 #endif
8130 }
8131 return resultobj;
8132 fail:
8133 return NULL;
8134 }
8135
8136
8137 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8138 PyObject *resultobj;
8139 wxFSFile *arg1 = (wxFSFile *) 0 ;
8140 wxString *result;
8141 PyObject * obj0 = 0 ;
8142 char *kwnames[] = {
8143 (char *) "self", NULL
8144 };
8145
8146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8148 if (SWIG_arg_fail(1)) SWIG_fail;
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 {
8152 wxString const &_result_ref = (arg1)->GetLocation();
8153 result = (wxString *) &_result_ref;
8154 }
8155
8156 wxPyEndAllowThreads(__tstate);
8157 if (PyErr_Occurred()) SWIG_fail;
8158 }
8159 {
8160 #if wxUSE_UNICODE
8161 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8162 #else
8163 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8164 #endif
8165 }
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8173 PyObject *resultobj;
8174 wxFSFile *arg1 = (wxFSFile *) 0 ;
8175 wxString *result;
8176 PyObject * obj0 = 0 ;
8177 char *kwnames[] = {
8178 (char *) "self", NULL
8179 };
8180
8181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8183 if (SWIG_arg_fail(1)) SWIG_fail;
8184 {
8185 PyThreadState* __tstate = wxPyBeginAllowThreads();
8186 {
8187 wxString const &_result_ref = (arg1)->GetAnchor();
8188 result = (wxString *) &_result_ref;
8189 }
8190
8191 wxPyEndAllowThreads(__tstate);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 {
8195 #if wxUSE_UNICODE
8196 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8197 #else
8198 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8199 #endif
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxFSFile *arg1 = (wxFSFile *) 0 ;
8210 wxDateTime result;
8211 PyObject * obj0 = 0 ;
8212 char *kwnames[] = {
8213 (char *) "self", NULL
8214 };
8215
8216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8218 if (SWIG_arg_fail(1)) SWIG_fail;
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = (arg1)->GetModificationTime();
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 wxDateTime * resultptr;
8228 resultptr = new wxDateTime((wxDateTime &)(result));
8229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8230 }
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8238 PyObject *obj;
8239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8240 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8241 Py_INCREF(obj);
8242 return Py_BuildValue((char *)"");
8243 }
8244 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj;
8253 wxPyFileSystemHandler *result;
8254 char *kwnames[] = {
8255 NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8262
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8274 PyObject *resultobj;
8275 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8276 PyObject *arg2 = (PyObject *) 0 ;
8277 PyObject *arg3 = (PyObject *) 0 ;
8278 PyObject * obj0 = 0 ;
8279 PyObject * obj1 = 0 ;
8280 PyObject * obj2 = 0 ;
8281 char *kwnames[] = {
8282 (char *) "self",(char *) "self",(char *) "_class", NULL
8283 };
8284
8285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8287 if (SWIG_arg_fail(1)) SWIG_fail;
8288 arg2 = obj1;
8289 arg3 = obj2;
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 (arg1)->_setCallbackInfo(arg2,arg3);
8293
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 Py_INCREF(Py_None); resultobj = Py_None;
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj;
8306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8307 wxString *arg2 = 0 ;
8308 bool result;
8309 bool temp2 = false ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char *kwnames[] = {
8313 (char *) "self",(char *) "location", NULL
8314 };
8315
8316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8318 if (SWIG_arg_fail(1)) SWIG_fail;
8319 {
8320 arg2 = wxString_in_helper(obj1);
8321 if (arg2 == NULL) SWIG_fail;
8322 temp2 = true;
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8327
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 {
8332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8333 }
8334 {
8335 if (temp2)
8336 delete arg2;
8337 }
8338 return resultobj;
8339 fail:
8340 {
8341 if (temp2)
8342 delete arg2;
8343 }
8344 return NULL;
8345 }
8346
8347
8348 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj;
8350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8351 wxFileSystem *arg2 = 0 ;
8352 wxString *arg3 = 0 ;
8353 wxFSFile *result;
8354 bool temp3 = false ;
8355 PyObject * obj0 = 0 ;
8356 PyObject * obj1 = 0 ;
8357 PyObject * obj2 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self",(char *) "fs",(char *) "location", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 {
8366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8367 if (SWIG_arg_fail(2)) SWIG_fail;
8368 if (arg2 == NULL) {
8369 SWIG_null_ref("wxFileSystem");
8370 }
8371 if (SWIG_arg_fail(2)) SWIG_fail;
8372 }
8373 {
8374 arg3 = wxString_in_helper(obj2);
8375 if (arg3 == NULL) SWIG_fail;
8376 temp3 = true;
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 {
8386 resultobj = wxPyMake_wxObject(result, 1);
8387 }
8388 {
8389 if (temp3)
8390 delete arg3;
8391 }
8392 return resultobj;
8393 fail:
8394 {
8395 if (temp3)
8396 delete arg3;
8397 }
8398 return NULL;
8399 }
8400
8401
8402 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj;
8404 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8405 wxString *arg2 = 0 ;
8406 int arg3 = (int) 0 ;
8407 wxString result;
8408 bool temp2 = false ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 PyObject * obj2 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self",(char *) "spec",(char *) "flags", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 arg2 = wxString_in_helper(obj1);
8421 if (arg2 == NULL) SWIG_fail;
8422 temp2 = true;
8423 }
8424 if (obj2) {
8425 {
8426 arg3 = (int)(SWIG_As_int(obj2));
8427 if (SWIG_arg_fail(3)) SWIG_fail;
8428 }
8429 }
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8433
8434 wxPyEndAllowThreads(__tstate);
8435 if (PyErr_Occurred()) SWIG_fail;
8436 }
8437 {
8438 #if wxUSE_UNICODE
8439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8440 #else
8441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8442 #endif
8443 }
8444 {
8445 if (temp2)
8446 delete arg2;
8447 }
8448 return resultobj;
8449 fail:
8450 {
8451 if (temp2)
8452 delete arg2;
8453 }
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj;
8460 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8461 wxString result;
8462 PyObject * obj0 = 0 ;
8463 char *kwnames[] = {
8464 (char *) "self", NULL
8465 };
8466
8467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8469 if (SWIG_arg_fail(1)) SWIG_fail;
8470 {
8471 PyThreadState* __tstate = wxPyBeginAllowThreads();
8472 result = (arg1)->FindNext();
8473
8474 wxPyEndAllowThreads(__tstate);
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 {
8478 #if wxUSE_UNICODE
8479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8480 #else
8481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8482 #endif
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8493 wxString *arg2 = 0 ;
8494 wxString result;
8495 bool temp2 = false ;
8496 PyObject * obj0 = 0 ;
8497 PyObject * obj1 = 0 ;
8498 char *kwnames[] = {
8499 (char *) "self",(char *) "location", NULL
8500 };
8501
8502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8504 if (SWIG_arg_fail(1)) SWIG_fail;
8505 {
8506 arg2 = wxString_in_helper(obj1);
8507 if (arg2 == NULL) SWIG_fail;
8508 temp2 = true;
8509 }
8510 {
8511 PyThreadState* __tstate = wxPyBeginAllowThreads();
8512 result = (arg1)->GetProtocol((wxString const &)*arg2);
8513
8514 wxPyEndAllowThreads(__tstate);
8515 if (PyErr_Occurred()) SWIG_fail;
8516 }
8517 {
8518 #if wxUSE_UNICODE
8519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8520 #else
8521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8522 #endif
8523 }
8524 {
8525 if (temp2)
8526 delete arg2;
8527 }
8528 return resultobj;
8529 fail:
8530 {
8531 if (temp2)
8532 delete arg2;
8533 }
8534 return NULL;
8535 }
8536
8537
8538 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj;
8540 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8541 wxString *arg2 = 0 ;
8542 wxString result;
8543 bool temp2 = false ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char *kwnames[] = {
8547 (char *) "self",(char *) "location", NULL
8548 };
8549
8550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8552 if (SWIG_arg_fail(1)) SWIG_fail;
8553 {
8554 arg2 = wxString_in_helper(obj1);
8555 if (arg2 == NULL) SWIG_fail;
8556 temp2 = true;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8561
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 #if wxUSE_UNICODE
8567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8568 #else
8569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8570 #endif
8571 }
8572 {
8573 if (temp2)
8574 delete arg2;
8575 }
8576 return resultobj;
8577 fail:
8578 {
8579 if (temp2)
8580 delete arg2;
8581 }
8582 return NULL;
8583 }
8584
8585
8586 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8587 PyObject *resultobj;
8588 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8589 wxString *arg2 = 0 ;
8590 wxString result;
8591 bool temp2 = false ;
8592 PyObject * obj0 = 0 ;
8593 PyObject * obj1 = 0 ;
8594 char *kwnames[] = {
8595 (char *) "self",(char *) "location", NULL
8596 };
8597
8598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8600 if (SWIG_arg_fail(1)) SWIG_fail;
8601 {
8602 arg2 = wxString_in_helper(obj1);
8603 if (arg2 == NULL) SWIG_fail;
8604 temp2 = true;
8605 }
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 result = (arg1)->GetAnchor((wxString const &)*arg2);
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 {
8614 #if wxUSE_UNICODE
8615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8616 #else
8617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8618 #endif
8619 }
8620 {
8621 if (temp2)
8622 delete arg2;
8623 }
8624 return resultobj;
8625 fail:
8626 {
8627 if (temp2)
8628 delete arg2;
8629 }
8630 return NULL;
8631 }
8632
8633
8634 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj;
8636 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8637 wxString *arg2 = 0 ;
8638 wxString result;
8639 bool temp2 = false ;
8640 PyObject * obj0 = 0 ;
8641 PyObject * obj1 = 0 ;
8642 char *kwnames[] = {
8643 (char *) "self",(char *) "location", NULL
8644 };
8645
8646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8648 if (SWIG_arg_fail(1)) SWIG_fail;
8649 {
8650 arg2 = wxString_in_helper(obj1);
8651 if (arg2 == NULL) SWIG_fail;
8652 temp2 = true;
8653 }
8654 {
8655 PyThreadState* __tstate = wxPyBeginAllowThreads();
8656 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8657
8658 wxPyEndAllowThreads(__tstate);
8659 if (PyErr_Occurred()) SWIG_fail;
8660 }
8661 {
8662 #if wxUSE_UNICODE
8663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8664 #else
8665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8666 #endif
8667 }
8668 {
8669 if (temp2)
8670 delete arg2;
8671 }
8672 return resultobj;
8673 fail:
8674 {
8675 if (temp2)
8676 delete arg2;
8677 }
8678 return NULL;
8679 }
8680
8681
8682 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8683 PyObject *resultobj;
8684 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8685 wxString *arg2 = 0 ;
8686 wxString result;
8687 bool temp2 = false ;
8688 PyObject * obj0 = 0 ;
8689 PyObject * obj1 = 0 ;
8690 char *kwnames[] = {
8691 (char *) "self",(char *) "location", NULL
8692 };
8693
8694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8696 if (SWIG_arg_fail(1)) SWIG_fail;
8697 {
8698 arg2 = wxString_in_helper(obj1);
8699 if (arg2 == NULL) SWIG_fail;
8700 temp2 = true;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8705
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 {
8710 #if wxUSE_UNICODE
8711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8712 #else
8713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8714 #endif
8715 }
8716 {
8717 if (temp2)
8718 delete arg2;
8719 }
8720 return resultobj;
8721 fail:
8722 {
8723 if (temp2)
8724 delete arg2;
8725 }
8726 return NULL;
8727 }
8728
8729
8730 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8731 PyObject *obj;
8732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8733 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8734 Py_INCREF(obj);
8735 return Py_BuildValue((char *)"");
8736 }
8737 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8738 PyObject *resultobj;
8739 wxFileSystem *result;
8740 char *kwnames[] = {
8741 NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8745 {
8746 PyThreadState* __tstate = wxPyBeginAllowThreads();
8747 result = (wxFileSystem *)new wxFileSystem();
8748
8749 wxPyEndAllowThreads(__tstate);
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 {
8753 resultobj = wxPyMake_wxObject(result, 1);
8754 }
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj;
8763 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8764 PyObject * obj0 = 0 ;
8765 char *kwnames[] = {
8766 (char *) "self", NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8771 if (SWIG_arg_fail(1)) SWIG_fail;
8772 {
8773 PyThreadState* __tstate = wxPyBeginAllowThreads();
8774 delete arg1;
8775
8776 wxPyEndAllowThreads(__tstate);
8777 if (PyErr_Occurred()) SWIG_fail;
8778 }
8779 Py_INCREF(Py_None); resultobj = Py_None;
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj;
8788 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8789 wxString *arg2 = 0 ;
8790 bool arg3 = (bool) false ;
8791 bool temp2 = false ;
8792 PyObject * obj0 = 0 ;
8793 PyObject * obj1 = 0 ;
8794 PyObject * obj2 = 0 ;
8795 char *kwnames[] = {
8796 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8797 };
8798
8799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8801 if (SWIG_arg_fail(1)) SWIG_fail;
8802 {
8803 arg2 = wxString_in_helper(obj1);
8804 if (arg2 == NULL) SWIG_fail;
8805 temp2 = true;
8806 }
8807 if (obj2) {
8808 {
8809 arg3 = (bool)(SWIG_As_bool(obj2));
8810 if (SWIG_arg_fail(3)) SWIG_fail;
8811 }
8812 }
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8816
8817 wxPyEndAllowThreads(__tstate);
8818 if (PyErr_Occurred()) SWIG_fail;
8819 }
8820 Py_INCREF(Py_None); resultobj = Py_None;
8821 {
8822 if (temp2)
8823 delete arg2;
8824 }
8825 return resultobj;
8826 fail:
8827 {
8828 if (temp2)
8829 delete arg2;
8830 }
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8838 wxString result;
8839 PyObject * obj0 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "self", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8846 if (SWIG_arg_fail(1)) SWIG_fail;
8847 {
8848 PyThreadState* __tstate = wxPyBeginAllowThreads();
8849 result = (arg1)->GetPath();
8850
8851 wxPyEndAllowThreads(__tstate);
8852 if (PyErr_Occurred()) SWIG_fail;
8853 }
8854 {
8855 #if wxUSE_UNICODE
8856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8857 #else
8858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8859 #endif
8860 }
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8870 wxString *arg2 = 0 ;
8871 wxFSFile *result;
8872 bool temp2 = false ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 char *kwnames[] = {
8876 (char *) "self",(char *) "location", NULL
8877 };
8878
8879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8881 if (SWIG_arg_fail(1)) SWIG_fail;
8882 {
8883 arg2 = wxString_in_helper(obj1);
8884 if (arg2 == NULL) SWIG_fail;
8885 temp2 = true;
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 {
8895 resultobj = wxPyMake_wxObject(result, 1);
8896 }
8897 {
8898 if (temp2)
8899 delete arg2;
8900 }
8901 return resultobj;
8902 fail:
8903 {
8904 if (temp2)
8905 delete arg2;
8906 }
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 wxString *arg2 = 0 ;
8915 int arg3 = (int) 0 ;
8916 wxString result;
8917 bool temp2 = false ;
8918 PyObject * obj0 = 0 ;
8919 PyObject * obj1 = 0 ;
8920 PyObject * obj2 = 0 ;
8921 char *kwnames[] = {
8922 (char *) "self",(char *) "spec",(char *) "flags", NULL
8923 };
8924
8925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8927 if (SWIG_arg_fail(1)) SWIG_fail;
8928 {
8929 arg2 = wxString_in_helper(obj1);
8930 if (arg2 == NULL) SWIG_fail;
8931 temp2 = true;
8932 }
8933 if (obj2) {
8934 {
8935 arg3 = (int)(SWIG_As_int(obj2));
8936 if (SWIG_arg_fail(3)) SWIG_fail;
8937 }
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8942
8943 wxPyEndAllowThreads(__tstate);
8944 if (PyErr_Occurred()) SWIG_fail;
8945 }
8946 {
8947 #if wxUSE_UNICODE
8948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8949 #else
8950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8951 #endif
8952 }
8953 {
8954 if (temp2)
8955 delete arg2;
8956 }
8957 return resultobj;
8958 fail:
8959 {
8960 if (temp2)
8961 delete arg2;
8962 }
8963 return NULL;
8964 }
8965
8966
8967 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj;
8969 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8970 wxString result;
8971 PyObject * obj0 = 0 ;
8972 char *kwnames[] = {
8973 (char *) "self", NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8978 if (SWIG_arg_fail(1)) SWIG_fail;
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 result = (arg1)->FindNext();
8982
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 {
8987 #if wxUSE_UNICODE
8988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8989 #else
8990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8991 #endif
8992 }
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9002 PyObject * obj0 = 0 ;
9003 char *kwnames[] = {
9004 (char *) "handler", NULL
9005 };
9006
9007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9009 if (SWIG_arg_fail(1)) SWIG_fail;
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 wxFileSystem::AddHandler(arg1);
9013
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 Py_INCREF(Py_None); resultobj = Py_None;
9018 return resultobj;
9019 fail:
9020 return NULL;
9021 }
9022
9023
9024 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj;
9026 char *kwnames[] = {
9027 NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 wxFileSystem::CleanUpHandlers();
9034
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 Py_INCREF(Py_None); resultobj = Py_None;
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 wxString *arg1 = 0 ;
9048 wxString result;
9049 bool temp1 = false ;
9050 PyObject * obj0 = 0 ;
9051 char *kwnames[] = {
9052 (char *) "filename", NULL
9053 };
9054
9055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9056 {
9057 arg1 = wxString_in_helper(obj0);
9058 if (arg1 == NULL) SWIG_fail;
9059 temp1 = true;
9060 }
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 {
9069 #if wxUSE_UNICODE
9070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9071 #else
9072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9073 #endif
9074 }
9075 {
9076 if (temp1)
9077 delete arg1;
9078 }
9079 return resultobj;
9080 fail:
9081 {
9082 if (temp1)
9083 delete arg1;
9084 }
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxString *arg1 = 0 ;
9092 wxString result;
9093 bool temp1 = false ;
9094 PyObject * obj0 = 0 ;
9095 char *kwnames[] = {
9096 (char *) "url", NULL
9097 };
9098
9099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9100 {
9101 arg1 = wxString_in_helper(obj0);
9102 if (arg1 == NULL) SWIG_fail;
9103 temp1 = true;
9104 }
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 result = FileSystem_URLToFileName((wxString const &)*arg1);
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 {
9113 #if wxUSE_UNICODE
9114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9115 #else
9116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9117 #endif
9118 }
9119 {
9120 if (temp1)
9121 delete arg1;
9122 }
9123 return resultobj;
9124 fail:
9125 {
9126 if (temp1)
9127 delete arg1;
9128 }
9129 return NULL;
9130 }
9131
9132
9133 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9134 PyObject *obj;
9135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9136 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9137 Py_INCREF(obj);
9138 return Py_BuildValue((char *)"");
9139 }
9140 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj;
9142 wxInternetFSHandler *result;
9143 char *kwnames[] = {
9144 NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9148 {
9149 PyThreadState* __tstate = wxPyBeginAllowThreads();
9150 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9151
9152 wxPyEndAllowThreads(__tstate);
9153 if (PyErr_Occurred()) SWIG_fail;
9154 }
9155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9165 wxString *arg2 = 0 ;
9166 bool result;
9167 bool temp2 = false ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char *kwnames[] = {
9171 (char *) "self",(char *) "location", NULL
9172 };
9173
9174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9176 if (SWIG_arg_fail(1)) SWIG_fail;
9177 {
9178 arg2 = wxString_in_helper(obj1);
9179 if (arg2 == NULL) SWIG_fail;
9180 temp2 = true;
9181 }
9182 {
9183 PyThreadState* __tstate = wxPyBeginAllowThreads();
9184 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9185
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 {
9190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9191 }
9192 {
9193 if (temp2)
9194 delete arg2;
9195 }
9196 return resultobj;
9197 fail:
9198 {
9199 if (temp2)
9200 delete arg2;
9201 }
9202 return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9207 PyObject *resultobj;
9208 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9209 wxFileSystem *arg2 = 0 ;
9210 wxString *arg3 = 0 ;
9211 wxFSFile *result;
9212 bool temp3 = false ;
9213 PyObject * obj0 = 0 ;
9214 PyObject * obj1 = 0 ;
9215 PyObject * obj2 = 0 ;
9216 char *kwnames[] = {
9217 (char *) "self",(char *) "fs",(char *) "location", NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9222 if (SWIG_arg_fail(1)) SWIG_fail;
9223 {
9224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9225 if (SWIG_arg_fail(2)) SWIG_fail;
9226 if (arg2 == NULL) {
9227 SWIG_null_ref("wxFileSystem");
9228 }
9229 if (SWIG_arg_fail(2)) SWIG_fail;
9230 }
9231 {
9232 arg3 = wxString_in_helper(obj2);
9233 if (arg3 == NULL) SWIG_fail;
9234 temp3 = true;
9235 }
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9239
9240 wxPyEndAllowThreads(__tstate);
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 {
9244 resultobj = wxPyMake_wxObject(result, 1);
9245 }
9246 {
9247 if (temp3)
9248 delete arg3;
9249 }
9250 return resultobj;
9251 fail:
9252 {
9253 if (temp3)
9254 delete arg3;
9255 }
9256 return NULL;
9257 }
9258
9259
9260 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9261 PyObject *obj;
9262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9263 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9264 Py_INCREF(obj);
9265 return Py_BuildValue((char *)"");
9266 }
9267 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 wxZipFSHandler *result;
9270 char *kwnames[] = {
9271 NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (wxZipFSHandler *)new wxZipFSHandler();
9278
9279 wxPyEndAllowThreads(__tstate);
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9292 wxString *arg2 = 0 ;
9293 bool result;
9294 bool temp2 = false ;
9295 PyObject * obj0 = 0 ;
9296 PyObject * obj1 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "self",(char *) "location", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9303 if (SWIG_arg_fail(1)) SWIG_fail;
9304 {
9305 arg2 = wxString_in_helper(obj1);
9306 if (arg2 == NULL) SWIG_fail;
9307 temp2 = true;
9308 }
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 {
9317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9318 }
9319 {
9320 if (temp2)
9321 delete arg2;
9322 }
9323 return resultobj;
9324 fail:
9325 {
9326 if (temp2)
9327 delete arg2;
9328 }
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9336 wxFileSystem *arg2 = 0 ;
9337 wxString *arg3 = 0 ;
9338 wxFSFile *result;
9339 bool temp3 = false ;
9340 PyObject * obj0 = 0 ;
9341 PyObject * obj1 = 0 ;
9342 PyObject * obj2 = 0 ;
9343 char *kwnames[] = {
9344 (char *) "self",(char *) "fs",(char *) "location", NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9349 if (SWIG_arg_fail(1)) SWIG_fail;
9350 {
9351 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(2)) SWIG_fail;
9353 if (arg2 == NULL) {
9354 SWIG_null_ref("wxFileSystem");
9355 }
9356 if (SWIG_arg_fail(2)) SWIG_fail;
9357 }
9358 {
9359 arg3 = wxString_in_helper(obj2);
9360 if (arg3 == NULL) SWIG_fail;
9361 temp3 = true;
9362 }
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 resultobj = wxPyMake_wxObject(result, 1);
9372 }
9373 {
9374 if (temp3)
9375 delete arg3;
9376 }
9377 return resultobj;
9378 fail:
9379 {
9380 if (temp3)
9381 delete arg3;
9382 }
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9390 wxString *arg2 = 0 ;
9391 int arg3 = (int) 0 ;
9392 wxString result;
9393 bool temp2 = false ;
9394 PyObject * obj0 = 0 ;
9395 PyObject * obj1 = 0 ;
9396 PyObject * obj2 = 0 ;
9397 char *kwnames[] = {
9398 (char *) "self",(char *) "spec",(char *) "flags", NULL
9399 };
9400
9401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9403 if (SWIG_arg_fail(1)) SWIG_fail;
9404 {
9405 arg2 = wxString_in_helper(obj1);
9406 if (arg2 == NULL) SWIG_fail;
9407 temp2 = true;
9408 }
9409 if (obj2) {
9410 {
9411 arg3 = (int)(SWIG_As_int(obj2));
9412 if (SWIG_arg_fail(3)) SWIG_fail;
9413 }
9414 }
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 #if wxUSE_UNICODE
9424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9425 #else
9426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9427 #endif
9428 }
9429 {
9430 if (temp2)
9431 delete arg2;
9432 }
9433 return resultobj;
9434 fail:
9435 {
9436 if (temp2)
9437 delete arg2;
9438 }
9439 return NULL;
9440 }
9441
9442
9443 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj;
9445 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9446 wxString result;
9447 PyObject * obj0 = 0 ;
9448 char *kwnames[] = {
9449 (char *) "self", NULL
9450 };
9451
9452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9454 if (SWIG_arg_fail(1)) SWIG_fail;
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 result = (arg1)->FindNext();
9458
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 #if wxUSE_UNICODE
9464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9465 #else
9466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9467 #endif
9468 }
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9476 PyObject *obj;
9477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9478 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9479 Py_INCREF(obj);
9480 return Py_BuildValue((char *)"");
9481 }
9482 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj;
9484 wxString *arg1 = 0 ;
9485 wxImage *arg2 = 0 ;
9486 long arg3 ;
9487 bool temp1 = false ;
9488 PyObject * obj0 = 0 ;
9489 PyObject * obj1 = 0 ;
9490 PyObject * obj2 = 0 ;
9491 char *kwnames[] = {
9492 (char *) "filename",(char *) "image",(char *) "type", NULL
9493 };
9494
9495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9496 {
9497 arg1 = wxString_in_helper(obj0);
9498 if (arg1 == NULL) SWIG_fail;
9499 temp1 = true;
9500 }
9501 {
9502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9503 if (SWIG_arg_fail(2)) SWIG_fail;
9504 if (arg2 == NULL) {
9505 SWIG_null_ref("wxImage");
9506 }
9507 if (SWIG_arg_fail(2)) SWIG_fail;
9508 }
9509 {
9510 arg3 = (long)(SWIG_As_long(obj2));
9511 if (SWIG_arg_fail(3)) SWIG_fail;
9512 }
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 Py_INCREF(Py_None); resultobj = Py_None;
9521 {
9522 if (temp1)
9523 delete arg1;
9524 }
9525 return resultobj;
9526 fail:
9527 {
9528 if (temp1)
9529 delete arg1;
9530 }
9531 return NULL;
9532 }
9533
9534
9535 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj;
9537 wxString *arg1 = 0 ;
9538 wxBitmap *arg2 = 0 ;
9539 long arg3 ;
9540 bool temp1 = false ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 PyObject * obj2 = 0 ;
9544 char *kwnames[] = {
9545 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9546 };
9547
9548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9549 {
9550 arg1 = wxString_in_helper(obj0);
9551 if (arg1 == NULL) SWIG_fail;
9552 temp1 = true;
9553 }
9554 {
9555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9556 if (SWIG_arg_fail(2)) SWIG_fail;
9557 if (arg2 == NULL) {
9558 SWIG_null_ref("wxBitmap");
9559 }
9560 if (SWIG_arg_fail(2)) SWIG_fail;
9561 }
9562 {
9563 arg3 = (long)(SWIG_As_long(obj2));
9564 if (SWIG_arg_fail(3)) SWIG_fail;
9565 }
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9569
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 Py_INCREF(Py_None); resultobj = Py_None;
9574 {
9575 if (temp1)
9576 delete arg1;
9577 }
9578 return resultobj;
9579 fail:
9580 {
9581 if (temp1)
9582 delete arg1;
9583 }
9584 return NULL;
9585 }
9586
9587
9588 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9589 PyObject *resultobj;
9590 wxString *arg1 = 0 ;
9591 PyObject *arg2 = (PyObject *) 0 ;
9592 bool temp1 = false ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 char *kwnames[] = {
9596 (char *) "filename",(char *) "data", NULL
9597 };
9598
9599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9600 {
9601 arg1 = wxString_in_helper(obj0);
9602 if (arg1 == NULL) SWIG_fail;
9603 temp1 = true;
9604 }
9605 arg2 = obj1;
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 Py_INCREF(Py_None); resultobj = Py_None;
9614 {
9615 if (temp1)
9616 delete arg1;
9617 }
9618 return resultobj;
9619 fail:
9620 {
9621 if (temp1)
9622 delete arg1;
9623 }
9624 return NULL;
9625 }
9626
9627
9628 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj;
9630 wxMemoryFSHandler *result;
9631 char *kwnames[] = {
9632 NULL
9633 };
9634
9635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9636 {
9637 PyThreadState* __tstate = wxPyBeginAllowThreads();
9638 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9639
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9651 PyObject *resultobj;
9652 wxString *arg1 = 0 ;
9653 bool temp1 = false ;
9654 PyObject * obj0 = 0 ;
9655 char *kwnames[] = {
9656 (char *) "filename", NULL
9657 };
9658
9659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9660 {
9661 arg1 = wxString_in_helper(obj0);
9662 if (arg1 == NULL) SWIG_fail;
9663 temp1 = true;
9664 }
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9668
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 Py_INCREF(Py_None); resultobj = Py_None;
9673 {
9674 if (temp1)
9675 delete arg1;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp1)
9681 delete arg1;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9690 wxString *arg2 = 0 ;
9691 bool result;
9692 bool temp2 = false ;
9693 PyObject * obj0 = 0 ;
9694 PyObject * obj1 = 0 ;
9695 char *kwnames[] = {
9696 (char *) "self",(char *) "location", NULL
9697 };
9698
9699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9701 if (SWIG_arg_fail(1)) SWIG_fail;
9702 {
9703 arg2 = wxString_in_helper(obj1);
9704 if (arg2 == NULL) SWIG_fail;
9705 temp2 = true;
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9716 }
9717 {
9718 if (temp2)
9719 delete arg2;
9720 }
9721 return resultobj;
9722 fail:
9723 {
9724 if (temp2)
9725 delete arg2;
9726 }
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9734 wxFileSystem *arg2 = 0 ;
9735 wxString *arg3 = 0 ;
9736 wxFSFile *result;
9737 bool temp3 = false ;
9738 PyObject * obj0 = 0 ;
9739 PyObject * obj1 = 0 ;
9740 PyObject * obj2 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "self",(char *) "fs",(char *) "location", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9747 if (SWIG_arg_fail(1)) SWIG_fail;
9748 {
9749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9750 if (SWIG_arg_fail(2)) SWIG_fail;
9751 if (arg2 == NULL) {
9752 SWIG_null_ref("wxFileSystem");
9753 }
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 {
9757 arg3 = wxString_in_helper(obj2);
9758 if (arg3 == NULL) SWIG_fail;
9759 temp3 = true;
9760 }
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 {
9769 resultobj = wxPyMake_wxObject(result, 1);
9770 }
9771 {
9772 if (temp3)
9773 delete arg3;
9774 }
9775 return resultobj;
9776 fail:
9777 {
9778 if (temp3)
9779 delete arg3;
9780 }
9781 return NULL;
9782 }
9783
9784
9785 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9786 PyObject *resultobj;
9787 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9788 wxString *arg2 = 0 ;
9789 int arg3 = (int) 0 ;
9790 wxString result;
9791 bool temp2 = false ;
9792 PyObject * obj0 = 0 ;
9793 PyObject * obj1 = 0 ;
9794 PyObject * obj2 = 0 ;
9795 char *kwnames[] = {
9796 (char *) "self",(char *) "spec",(char *) "flags", NULL
9797 };
9798
9799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9801 if (SWIG_arg_fail(1)) SWIG_fail;
9802 {
9803 arg2 = wxString_in_helper(obj1);
9804 if (arg2 == NULL) SWIG_fail;
9805 temp2 = true;
9806 }
9807 if (obj2) {
9808 {
9809 arg3 = (int)(SWIG_As_int(obj2));
9810 if (SWIG_arg_fail(3)) SWIG_fail;
9811 }
9812 }
9813 {
9814 PyThreadState* __tstate = wxPyBeginAllowThreads();
9815 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9816
9817 wxPyEndAllowThreads(__tstate);
9818 if (PyErr_Occurred()) SWIG_fail;
9819 }
9820 {
9821 #if wxUSE_UNICODE
9822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9823 #else
9824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9825 #endif
9826 }
9827 {
9828 if (temp2)
9829 delete arg2;
9830 }
9831 return resultobj;
9832 fail:
9833 {
9834 if (temp2)
9835 delete arg2;
9836 }
9837 return NULL;
9838 }
9839
9840
9841 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj;
9843 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9844 wxString result;
9845 PyObject * obj0 = 0 ;
9846 char *kwnames[] = {
9847 (char *) "self", NULL
9848 };
9849
9850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9852 if (SWIG_arg_fail(1)) SWIG_fail;
9853 {
9854 PyThreadState* __tstate = wxPyBeginAllowThreads();
9855 result = (arg1)->FindNext();
9856
9857 wxPyEndAllowThreads(__tstate);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 {
9861 #if wxUSE_UNICODE
9862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9863 #else
9864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9865 #endif
9866 }
9867 return resultobj;
9868 fail:
9869 return NULL;
9870 }
9871
9872
9873 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9874 PyObject *obj;
9875 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9876 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9877 Py_INCREF(obj);
9878 return Py_BuildValue((char *)"");
9879 }
9880 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj;
9882 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9883 wxString result;
9884 PyObject * obj0 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (arg1)->GetName();
9895
9896 wxPyEndAllowThreads(__tstate);
9897 if (PyErr_Occurred()) SWIG_fail;
9898 }
9899 {
9900 #if wxUSE_UNICODE
9901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9902 #else
9903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9904 #endif
9905 }
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9913 PyObject *resultobj;
9914 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9915 wxString result;
9916 PyObject * obj0 = 0 ;
9917 char *kwnames[] = {
9918 (char *) "self", NULL
9919 };
9920
9921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9923 if (SWIG_arg_fail(1)) SWIG_fail;
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (arg1)->GetExtension();
9927
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 {
9932 #if wxUSE_UNICODE
9933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9934 #else
9935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9936 #endif
9937 }
9938 return resultobj;
9939 fail:
9940 return NULL;
9941 }
9942
9943
9944 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9945 PyObject *resultobj;
9946 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9947 long result;
9948 PyObject * obj0 = 0 ;
9949 char *kwnames[] = {
9950 (char *) "self", NULL
9951 };
9952
9953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9955 if (SWIG_arg_fail(1)) SWIG_fail;
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 result = (long)(arg1)->GetType();
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 resultobj = SWIG_From_long((long)(result));
9965 }
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj;
9974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9975 wxString result;
9976 PyObject * obj0 = 0 ;
9977 char *kwnames[] = {
9978 (char *) "self", NULL
9979 };
9980
9981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9983 if (SWIG_arg_fail(1)) SWIG_fail;
9984 {
9985 PyThreadState* __tstate = wxPyBeginAllowThreads();
9986 result = (arg1)->GetMimeType();
9987
9988 wxPyEndAllowThreads(__tstate);
9989 if (PyErr_Occurred()) SWIG_fail;
9990 }
9991 {
9992 #if wxUSE_UNICODE
9993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9994 #else
9995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9996 #endif
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10007 wxString *arg2 = 0 ;
10008 bool result;
10009 bool temp2 = false ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 char *kwnames[] = {
10013 (char *) "self",(char *) "name", NULL
10014 };
10015
10016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10018 if (SWIG_arg_fail(1)) SWIG_fail;
10019 {
10020 arg2 = wxString_in_helper(obj1);
10021 if (arg2 == NULL) SWIG_fail;
10022 temp2 = true;
10023 }
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 {
10032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10033 }
10034 {
10035 if (temp2)
10036 delete arg2;
10037 }
10038 return resultobj;
10039 fail:
10040 {
10041 if (temp2)
10042 delete arg2;
10043 }
10044 return NULL;
10045 }
10046
10047
10048 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10049 PyObject *resultobj;
10050 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10051 wxString *arg2 = 0 ;
10052 bool temp2 = false ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char *kwnames[] = {
10056 (char *) "self",(char *) "name", NULL
10057 };
10058
10059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10061 if (SWIG_arg_fail(1)) SWIG_fail;
10062 {
10063 arg2 = wxString_in_helper(obj1);
10064 if (arg2 == NULL) SWIG_fail;
10065 temp2 = true;
10066 }
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 (arg1)->SetName((wxString const &)*arg2);
10070
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 Py_INCREF(Py_None); resultobj = Py_None;
10075 {
10076 if (temp2)
10077 delete arg2;
10078 }
10079 return resultobj;
10080 fail:
10081 {
10082 if (temp2)
10083 delete arg2;
10084 }
10085 return NULL;
10086 }
10087
10088
10089 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10090 PyObject *resultobj;
10091 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10092 wxString *arg2 = 0 ;
10093 bool temp2 = false ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char *kwnames[] = {
10097 (char *) "self",(char *) "extension", NULL
10098 };
10099
10100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10102 if (SWIG_arg_fail(1)) SWIG_fail;
10103 {
10104 arg2 = wxString_in_helper(obj1);
10105 if (arg2 == NULL) SWIG_fail;
10106 temp2 = true;
10107 }
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 (arg1)->SetExtension((wxString const &)*arg2);
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 Py_INCREF(Py_None); resultobj = Py_None;
10116 {
10117 if (temp2)
10118 delete arg2;
10119 }
10120 return resultobj;
10121 fail:
10122 {
10123 if (temp2)
10124 delete arg2;
10125 }
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj;
10132 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10133 long arg2 ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char *kwnames[] = {
10137 (char *) "self",(char *) "type", NULL
10138 };
10139
10140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10142 if (SWIG_arg_fail(1)) SWIG_fail;
10143 {
10144 arg2 = (long)(SWIG_As_long(obj1));
10145 if (SWIG_arg_fail(2)) SWIG_fail;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 (arg1)->SetType(arg2);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 return resultobj;
10156 fail:
10157 return NULL;
10158 }
10159
10160
10161 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj;
10163 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10164 wxString *arg2 = 0 ;
10165 bool temp2 = false ;
10166 PyObject * obj0 = 0 ;
10167 PyObject * obj1 = 0 ;
10168 char *kwnames[] = {
10169 (char *) "self",(char *) "mimetype", NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10174 if (SWIG_arg_fail(1)) SWIG_fail;
10175 {
10176 arg2 = wxString_in_helper(obj1);
10177 if (arg2 == NULL) SWIG_fail;
10178 temp2 = true;
10179 }
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 (arg1)->SetMimeType((wxString const &)*arg2);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 Py_INCREF(Py_None); resultobj = Py_None;
10188 {
10189 if (temp2)
10190 delete arg2;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp2)
10196 delete arg2;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10203 PyObject *obj;
10204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10205 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10206 Py_INCREF(obj);
10207 return Py_BuildValue((char *)"");
10208 }
10209 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj;
10211 wxImageHistogram *result;
10212 char *kwnames[] = {
10213 NULL
10214 };
10215
10216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 result = (wxImageHistogram *)new wxImageHistogram();
10220
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10232 PyObject *resultobj;
10233 byte arg1 ;
10234 byte arg2 ;
10235 byte arg3 ;
10236 unsigned long result;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 PyObject * obj2 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "r",(char *) "g",(char *) "b", NULL
10242 };
10243
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10245 {
10246 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10247 if (SWIG_arg_fail(1)) SWIG_fail;
10248 }
10249 {
10250 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10251 if (SWIG_arg_fail(2)) SWIG_fail;
10252 }
10253 {
10254 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10255 if (SWIG_arg_fail(3)) SWIG_fail;
10256 }
10257 {
10258 PyThreadState* __tstate = wxPyBeginAllowThreads();
10259 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10260
10261 wxPyEndAllowThreads(__tstate);
10262 if (PyErr_Occurred()) SWIG_fail;
10263 }
10264 {
10265 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10266 }
10267 return resultobj;
10268 fail:
10269 return NULL;
10270 }
10271
10272
10273 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10274 PyObject *resultobj;
10275 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10276 byte *arg2 = (byte *) 0 ;
10277 byte *arg3 = (byte *) 0 ;
10278 byte *arg4 = (byte *) 0 ;
10279 byte arg5 = (byte) 1 ;
10280 byte arg6 = (byte) 0 ;
10281 byte arg7 = (byte) 0 ;
10282 bool result;
10283 byte temp2 ;
10284 int res2 = 0 ;
10285 byte temp3 ;
10286 int res3 = 0 ;
10287 byte temp4 ;
10288 int res4 = 0 ;
10289 PyObject * obj0 = 0 ;
10290 PyObject * obj1 = 0 ;
10291 PyObject * obj2 = 0 ;
10292 PyObject * obj3 = 0 ;
10293 char *kwnames[] = {
10294 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10295 };
10296
10297 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10298 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10299 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10302 if (SWIG_arg_fail(1)) SWIG_fail;
10303 if (obj1) {
10304 {
10305 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10306 if (SWIG_arg_fail(5)) SWIG_fail;
10307 }
10308 }
10309 if (obj2) {
10310 {
10311 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10312 if (SWIG_arg_fail(6)) SWIG_fail;
10313 }
10314 }
10315 if (obj3) {
10316 {
10317 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10318 if (SWIG_arg_fail(7)) SWIG_fail;
10319 }
10320 }
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10324
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 {
10329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10330 }
10331 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10332 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10333 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10334 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10335 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10336 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10344 PyObject *resultobj;
10345 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10346 unsigned long arg2 ;
10347 unsigned long result;
10348 PyObject * obj0 = 0 ;
10349 PyObject * obj1 = 0 ;
10350 char *kwnames[] = {
10351 (char *) "self",(char *) "key", NULL
10352 };
10353
10354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10356 if (SWIG_arg_fail(1)) SWIG_fail;
10357 {
10358 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10359 if (SWIG_arg_fail(2)) SWIG_fail;
10360 }
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10364
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 {
10369 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10370 }
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10380 byte arg2 ;
10381 byte arg3 ;
10382 byte arg4 ;
10383 unsigned long result;
10384 PyObject * obj0 = 0 ;
10385 PyObject * obj1 = 0 ;
10386 PyObject * obj2 = 0 ;
10387 PyObject * obj3 = 0 ;
10388 char *kwnames[] = {
10389 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10390 };
10391
10392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10394 if (SWIG_arg_fail(1)) SWIG_fail;
10395 {
10396 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10397 if (SWIG_arg_fail(2)) SWIG_fail;
10398 }
10399 {
10400 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10401 if (SWIG_arg_fail(3)) SWIG_fail;
10402 }
10403 {
10404 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10405 if (SWIG_arg_fail(4)) SWIG_fail;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10410
10411 wxPyEndAllowThreads(__tstate);
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10416 }
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj;
10425 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10426 wxColour *arg2 = 0 ;
10427 unsigned long result;
10428 wxColour temp2 ;
10429 PyObject * obj0 = 0 ;
10430 PyObject * obj1 = 0 ;
10431 char *kwnames[] = {
10432 (char *) "self",(char *) "colour", NULL
10433 };
10434
10435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10437 if (SWIG_arg_fail(1)) SWIG_fail;
10438 {
10439 arg2 = &temp2;
10440 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10441 }
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10445
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 {
10450 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10451 }
10452 return resultobj;
10453 fail:
10454 return NULL;
10455 }
10456
10457
10458 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10459 PyObject *obj;
10460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10461 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10462 Py_INCREF(obj);
10463 return Py_BuildValue((char *)"");
10464 }
10465 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10466 PyObject *resultobj;
10467 wxString *arg1 = 0 ;
10468 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10469 int arg3 = (int) -1 ;
10470 wxImage *result;
10471 bool temp1 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "name",(char *) "type",(char *) "index", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10480 {
10481 arg1 = wxString_in_helper(obj0);
10482 if (arg1 == NULL) SWIG_fail;
10483 temp1 = true;
10484 }
10485 if (obj1) {
10486 {
10487 arg2 = (long)(SWIG_As_long(obj1));
10488 if (SWIG_arg_fail(2)) SWIG_fail;
10489 }
10490 }
10491 if (obj2) {
10492 {
10493 arg3 = (int)(SWIG_As_int(obj2));
10494 if (SWIG_arg_fail(3)) SWIG_fail;
10495 }
10496 }
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10505 {
10506 if (temp1)
10507 delete arg1;
10508 }
10509 return resultobj;
10510 fail:
10511 {
10512 if (temp1)
10513 delete arg1;
10514 }
10515 return NULL;
10516 }
10517
10518
10519 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10520 PyObject *resultobj;
10521 wxImage *arg1 = (wxImage *) 0 ;
10522 PyObject * obj0 = 0 ;
10523 char *kwnames[] = {
10524 (char *) "self", NULL
10525 };
10526
10527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10529 if (SWIG_arg_fail(1)) SWIG_fail;
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 delete arg1;
10533
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 Py_INCREF(Py_None); resultobj = Py_None;
10538 return resultobj;
10539 fail:
10540 return NULL;
10541 }
10542
10543
10544 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10545 PyObject *resultobj;
10546 wxString *arg1 = 0 ;
10547 wxString *arg2 = 0 ;
10548 int arg3 = (int) -1 ;
10549 wxImage *result;
10550 bool temp1 = false ;
10551 bool temp2 = false ;
10552 PyObject * obj0 = 0 ;
10553 PyObject * obj1 = 0 ;
10554 PyObject * obj2 = 0 ;
10555 char *kwnames[] = {
10556 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10557 };
10558
10559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10560 {
10561 arg1 = wxString_in_helper(obj0);
10562 if (arg1 == NULL) SWIG_fail;
10563 temp1 = true;
10564 }
10565 {
10566 arg2 = wxString_in_helper(obj1);
10567 if (arg2 == NULL) SWIG_fail;
10568 temp2 = true;
10569 }
10570 if (obj2) {
10571 {
10572 arg3 = (int)(SWIG_As_int(obj2));
10573 if (SWIG_arg_fail(3)) SWIG_fail;
10574 }
10575 }
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10579
10580 wxPyEndAllowThreads(__tstate);
10581 if (PyErr_Occurred()) SWIG_fail;
10582 }
10583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10584 {
10585 if (temp1)
10586 delete arg1;
10587 }
10588 {
10589 if (temp2)
10590 delete arg2;
10591 }
10592 return resultobj;
10593 fail:
10594 {
10595 if (temp1)
10596 delete arg1;
10597 }
10598 {
10599 if (temp2)
10600 delete arg2;
10601 }
10602 return NULL;
10603 }
10604
10605
10606 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj;
10608 wxInputStream *arg1 = 0 ;
10609 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10610 int arg3 = (int) -1 ;
10611 wxImage *result;
10612 wxPyInputStream *temp1 ;
10613 bool created1 ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 PyObject * obj2 = 0 ;
10617 char *kwnames[] = {
10618 (char *) "stream",(char *) "type",(char *) "index", NULL
10619 };
10620
10621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10622 {
10623 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10624 arg1 = temp1->m_wxis;
10625 created1 = false;
10626 } else {
10627 PyErr_Clear(); // clear the failure of the wxPyConvert above
10628 arg1 = wxPyCBInputStream_create(obj0, false);
10629 if (arg1 == NULL) {
10630 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10631 SWIG_fail;
10632 }
10633 created1 = true;
10634 }
10635 }
10636 if (obj1) {
10637 {
10638 arg2 = (long)(SWIG_As_long(obj1));
10639 if (SWIG_arg_fail(2)) SWIG_fail;
10640 }
10641 }
10642 if (obj2) {
10643 {
10644 arg3 = (int)(SWIG_As_int(obj2));
10645 if (SWIG_arg_fail(3)) SWIG_fail;
10646 }
10647 }
10648 {
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10651
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10656 {
10657 if (created1) delete arg1;
10658 }
10659 return resultobj;
10660 fail:
10661 {
10662 if (created1) delete arg1;
10663 }
10664 return NULL;
10665 }
10666
10667
10668 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10669 PyObject *resultobj;
10670 wxInputStream *arg1 = 0 ;
10671 wxString *arg2 = 0 ;
10672 int arg3 = (int) -1 ;
10673 wxImage *result;
10674 wxPyInputStream *temp1 ;
10675 bool created1 ;
10676 bool temp2 = false ;
10677 PyObject * obj0 = 0 ;
10678 PyObject * obj1 = 0 ;
10679 PyObject * obj2 = 0 ;
10680 char *kwnames[] = {
10681 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10685 {
10686 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10687 arg1 = temp1->m_wxis;
10688 created1 = false;
10689 } else {
10690 PyErr_Clear(); // clear the failure of the wxPyConvert above
10691 arg1 = wxPyCBInputStream_create(obj0, false);
10692 if (arg1 == NULL) {
10693 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10694 SWIG_fail;
10695 }
10696 created1 = true;
10697 }
10698 }
10699 {
10700 arg2 = wxString_in_helper(obj1);
10701 if (arg2 == NULL) SWIG_fail;
10702 temp2 = true;
10703 }
10704 if (obj2) {
10705 {
10706 arg3 = (int)(SWIG_As_int(obj2));
10707 if (SWIG_arg_fail(3)) SWIG_fail;
10708 }
10709 }
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10713
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10718 {
10719 if (created1) delete arg1;
10720 }
10721 {
10722 if (temp2)
10723 delete arg2;
10724 }
10725 return resultobj;
10726 fail:
10727 {
10728 if (created1) delete arg1;
10729 }
10730 {
10731 if (temp2)
10732 delete arg2;
10733 }
10734 return NULL;
10735 }
10736
10737
10738 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10739 PyObject *resultobj;
10740 int arg1 = (int) 0 ;
10741 int arg2 = (int) 0 ;
10742 bool arg3 = (bool) true ;
10743 wxImage *result;
10744 PyObject * obj0 = 0 ;
10745 PyObject * obj1 = 0 ;
10746 PyObject * obj2 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "width",(char *) "height",(char *) "clear", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10752 if (obj0) {
10753 {
10754 arg1 = (int)(SWIG_As_int(obj0));
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 }
10757 }
10758 if (obj1) {
10759 {
10760 arg2 = (int)(SWIG_As_int(obj1));
10761 if (SWIG_arg_fail(2)) SWIG_fail;
10762 }
10763 }
10764 if (obj2) {
10765 {
10766 arg3 = (bool)(SWIG_As_bool(obj2));
10767 if (SWIG_arg_fail(3)) SWIG_fail;
10768 }
10769 }
10770 {
10771 PyThreadState* __tstate = wxPyBeginAllowThreads();
10772 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10773
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj;
10786 wxBitmap *arg1 = 0 ;
10787 wxImage *result;
10788 PyObject * obj0 = 0 ;
10789 char *kwnames[] = {
10790 (char *) "bitmap", NULL
10791 };
10792
10793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10794 {
10795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 if (arg1 == NULL) {
10798 SWIG_null_ref("wxBitmap");
10799 }
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 }
10802 {
10803 if (!wxPyCheckForApp()) SWIG_fail;
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10806
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj;
10819 int arg1 ;
10820 int arg2 ;
10821 buffer arg3 ;
10822 int arg4 ;
10823 wxImage *result;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 PyObject * obj2 = 0 ;
10827 char *kwnames[] = {
10828 (char *) "width",(char *) "height",(char *) "data", NULL
10829 };
10830
10831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10832 {
10833 arg1 = (int)(SWIG_As_int(obj0));
10834 if (SWIG_arg_fail(1)) SWIG_fail;
10835 }
10836 {
10837 arg2 = (int)(SWIG_As_int(obj1));
10838 if (SWIG_arg_fail(2)) SWIG_fail;
10839 }
10840 {
10841 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10842 }
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10846
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj;
10859 int arg1 ;
10860 int arg2 ;
10861 buffer arg3 ;
10862 int arg4 ;
10863 buffer arg5 ;
10864 int arg6 ;
10865 wxImage *result;
10866 PyObject * obj0 = 0 ;
10867 PyObject * obj1 = 0 ;
10868 PyObject * obj2 = 0 ;
10869 PyObject * obj3 = 0 ;
10870 char *kwnames[] = {
10871 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10872 };
10873
10874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10875 {
10876 arg1 = (int)(SWIG_As_int(obj0));
10877 if (SWIG_arg_fail(1)) SWIG_fail;
10878 }
10879 {
10880 arg2 = (int)(SWIG_As_int(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 {
10884 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10885 }
10886 {
10887 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10888 }
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxImage *arg1 = (wxImage *) 0 ;
10906 int arg2 ;
10907 int arg3 ;
10908 bool arg4 = (bool) true ;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 PyObject * obj3 = 0 ;
10913 char *kwnames[] = {
10914 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10915 };
10916
10917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10919 if (SWIG_arg_fail(1)) SWIG_fail;
10920 {
10921 arg2 = (int)(SWIG_As_int(obj1));
10922 if (SWIG_arg_fail(2)) SWIG_fail;
10923 }
10924 {
10925 arg3 = (int)(SWIG_As_int(obj2));
10926 if (SWIG_arg_fail(3)) SWIG_fail;
10927 }
10928 if (obj3) {
10929 {
10930 arg4 = (bool)(SWIG_As_bool(obj3));
10931 if (SWIG_arg_fail(4)) SWIG_fail;
10932 }
10933 }
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->Create(arg2,arg3,arg4);
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 Py_INCREF(Py_None); resultobj = Py_None;
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxImage *arg1 = (wxImage *) 0 ;
10951 PyObject * obj0 = 0 ;
10952 char *kwnames[] = {
10953 (char *) "self", NULL
10954 };
10955
10956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10958 if (SWIG_arg_fail(1)) SWIG_fail;
10959 {
10960 PyThreadState* __tstate = wxPyBeginAllowThreads();
10961 (arg1)->Destroy();
10962
10963 wxPyEndAllowThreads(__tstate);
10964 if (PyErr_Occurred()) SWIG_fail;
10965 }
10966 Py_INCREF(Py_None); resultobj = Py_None;
10967 return resultobj;
10968 fail:
10969 return NULL;
10970 }
10971
10972
10973 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10974 PyObject *resultobj;
10975 wxImage *arg1 = (wxImage *) 0 ;
10976 int arg2 ;
10977 int arg3 ;
10978 SwigValueWrapper<wxImage > result;
10979 PyObject * obj0 = 0 ;
10980 PyObject * obj1 = 0 ;
10981 PyObject * obj2 = 0 ;
10982 char *kwnames[] = {
10983 (char *) "self",(char *) "width",(char *) "height", NULL
10984 };
10985
10986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10988 if (SWIG_arg_fail(1)) SWIG_fail;
10989 {
10990 arg2 = (int)(SWIG_As_int(obj1));
10991 if (SWIG_arg_fail(2)) SWIG_fail;
10992 }
10993 {
10994 arg3 = (int)(SWIG_As_int(obj2));
10995 if (SWIG_arg_fail(3)) SWIG_fail;
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (arg1)->Scale(arg2,arg3);
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 {
11005 wxImage * resultptr;
11006 resultptr = new wxImage((wxImage &)(result));
11007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxImage *arg1 = (wxImage *) 0 ;
11018 int arg2 ;
11019 int arg3 ;
11020 SwigValueWrapper<wxImage > result;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 char *kwnames[] = {
11025 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11026 };
11027
11028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11030 if (SWIG_arg_fail(1)) SWIG_fail;
11031 {
11032 arg2 = (int)(SWIG_As_int(obj1));
11033 if (SWIG_arg_fail(2)) SWIG_fail;
11034 }
11035 {
11036 arg3 = (int)(SWIG_As_int(obj2));
11037 if (SWIG_arg_fail(3)) SWIG_fail;
11038 }
11039 {
11040 PyThreadState* __tstate = wxPyBeginAllowThreads();
11041 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11042
11043 wxPyEndAllowThreads(__tstate);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 wxImage * resultptr;
11048 resultptr = new wxImage((wxImage &)(result));
11049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11050 }
11051 return resultobj;
11052 fail:
11053 return NULL;
11054 }
11055
11056
11057 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj;
11059 wxImage *arg1 = (wxImage *) 0 ;
11060 int arg2 ;
11061 int arg3 ;
11062 wxImage *result;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 PyObject * obj2 = 0 ;
11066 char *kwnames[] = {
11067 (char *) "self",(char *) "width",(char *) "height", NULL
11068 };
11069
11070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11072 if (SWIG_arg_fail(1)) SWIG_fail;
11073 {
11074 arg2 = (int)(SWIG_As_int(obj1));
11075 if (SWIG_arg_fail(2)) SWIG_fail;
11076 }
11077 {
11078 arg3 = (int)(SWIG_As_int(obj2));
11079 if (SWIG_arg_fail(3)) SWIG_fail;
11080 }
11081 {
11082 PyThreadState* __tstate = wxPyBeginAllowThreads();
11083 {
11084 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11085 result = (wxImage *) &_result_ref;
11086 }
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj;
11100 wxImage *arg1 = (wxImage *) 0 ;
11101 wxSize *arg2 = 0 ;
11102 wxPoint *arg3 = 0 ;
11103 int arg4 = (int) -1 ;
11104 int arg5 = (int) -1 ;
11105 int arg6 = (int) -1 ;
11106 wxImage *result;
11107 wxSize temp2 ;
11108 wxPoint temp3 ;
11109 PyObject * obj0 = 0 ;
11110 PyObject * obj1 = 0 ;
11111 PyObject * obj2 = 0 ;
11112 PyObject * obj3 = 0 ;
11113 PyObject * obj4 = 0 ;
11114 PyObject * obj5 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 arg2 = &temp2;
11124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11125 }
11126 {
11127 arg3 = &temp3;
11128 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11129 }
11130 if (obj3) {
11131 {
11132 arg4 = (int)(SWIG_As_int(obj3));
11133 if (SWIG_arg_fail(4)) SWIG_fail;
11134 }
11135 }
11136 if (obj4) {
11137 {
11138 arg5 = (int)(SWIG_As_int(obj4));
11139 if (SWIG_arg_fail(5)) SWIG_fail;
11140 }
11141 }
11142 if (obj5) {
11143 {
11144 arg6 = (int)(SWIG_As_int(obj5));
11145 if (SWIG_arg_fail(6)) SWIG_fail;
11146 }
11147 }
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 {
11151 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11152 result = (wxImage *) &_result_ref;
11153 }
11154
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxImage *arg1 = (wxImage *) 0 ;
11168 int arg2 ;
11169 int arg3 ;
11170 byte arg4 ;
11171 byte arg5 ;
11172 byte arg6 ;
11173 PyObject * obj0 = 0 ;
11174 PyObject * obj1 = 0 ;
11175 PyObject * obj2 = 0 ;
11176 PyObject * obj3 = 0 ;
11177 PyObject * obj4 = 0 ;
11178 PyObject * obj5 = 0 ;
11179 char *kwnames[] = {
11180 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11181 };
11182
11183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11185 if (SWIG_arg_fail(1)) SWIG_fail;
11186 {
11187 arg2 = (int)(SWIG_As_int(obj1));
11188 if (SWIG_arg_fail(2)) SWIG_fail;
11189 }
11190 {
11191 arg3 = (int)(SWIG_As_int(obj2));
11192 if (SWIG_arg_fail(3)) SWIG_fail;
11193 }
11194 {
11195 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11196 if (SWIG_arg_fail(4)) SWIG_fail;
11197 }
11198 {
11199 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11200 if (SWIG_arg_fail(5)) SWIG_fail;
11201 }
11202 {
11203 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11204 if (SWIG_arg_fail(6)) SWIG_fail;
11205 }
11206 {
11207 PyThreadState* __tstate = wxPyBeginAllowThreads();
11208 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11209
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 Py_INCREF(Py_None); resultobj = Py_None;
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj;
11222 wxImage *arg1 = (wxImage *) 0 ;
11223 wxRect *arg2 = 0 ;
11224 byte arg3 ;
11225 byte arg4 ;
11226 byte arg5 ;
11227 wxRect temp2 ;
11228 PyObject * obj0 = 0 ;
11229 PyObject * obj1 = 0 ;
11230 PyObject * obj2 = 0 ;
11231 PyObject * obj3 = 0 ;
11232 PyObject * obj4 = 0 ;
11233 char *kwnames[] = {
11234 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11235 };
11236
11237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11239 if (SWIG_arg_fail(1)) SWIG_fail;
11240 {
11241 arg2 = &temp2;
11242 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11243 }
11244 {
11245 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11246 if (SWIG_arg_fail(3)) SWIG_fail;
11247 }
11248 {
11249 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11250 if (SWIG_arg_fail(4)) SWIG_fail;
11251 }
11252 {
11253 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11254 if (SWIG_arg_fail(5)) SWIG_fail;
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 Py_INCREF(Py_None); resultobj = Py_None;
11264 return resultobj;
11265 fail:
11266 return NULL;
11267 }
11268
11269
11270 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11271 PyObject *resultobj;
11272 wxImage *arg1 = (wxImage *) 0 ;
11273 int arg2 ;
11274 int arg3 ;
11275 byte result;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "self",(char *) "x",(char *) "y", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(1)) SWIG_fail;
11286 {
11287 arg2 = (int)(SWIG_As_int(obj1));
11288 if (SWIG_arg_fail(2)) SWIG_fail;
11289 }
11290 {
11291 arg3 = (int)(SWIG_As_int(obj2));
11292 if (SWIG_arg_fail(3)) SWIG_fail;
11293 }
11294 {
11295 PyThreadState* __tstate = wxPyBeginAllowThreads();
11296 result = (byte)(arg1)->GetRed(arg2,arg3);
11297
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 {
11302 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11303 }
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj;
11312 wxImage *arg1 = (wxImage *) 0 ;
11313 int arg2 ;
11314 int arg3 ;
11315 byte result;
11316 PyObject * obj0 = 0 ;
11317 PyObject * obj1 = 0 ;
11318 PyObject * obj2 = 0 ;
11319 char *kwnames[] = {
11320 (char *) "self",(char *) "x",(char *) "y", NULL
11321 };
11322
11323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11325 if (SWIG_arg_fail(1)) SWIG_fail;
11326 {
11327 arg2 = (int)(SWIG_As_int(obj1));
11328 if (SWIG_arg_fail(2)) SWIG_fail;
11329 }
11330 {
11331 arg3 = (int)(SWIG_As_int(obj2));
11332 if (SWIG_arg_fail(3)) SWIG_fail;
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 result = (byte)(arg1)->GetGreen(arg2,arg3);
11337
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 {
11342 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11343 }
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 wxImage *arg1 = (wxImage *) 0 ;
11353 int arg2 ;
11354 int arg3 ;
11355 byte result;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 PyObject * obj2 = 0 ;
11359 char *kwnames[] = {
11360 (char *) "self",(char *) "x",(char *) "y", NULL
11361 };
11362
11363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11365 if (SWIG_arg_fail(1)) SWIG_fail;
11366 {
11367 arg2 = (int)(SWIG_As_int(obj1));
11368 if (SWIG_arg_fail(2)) SWIG_fail;
11369 }
11370 {
11371 arg3 = (int)(SWIG_As_int(obj2));
11372 if (SWIG_arg_fail(3)) SWIG_fail;
11373 }
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (byte)(arg1)->GetBlue(arg2,arg3);
11377
11378 wxPyEndAllowThreads(__tstate);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 {
11382 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxImage *arg1 = (wxImage *) 0 ;
11393 int arg2 ;
11394 int arg3 ;
11395 byte arg4 ;
11396 PyObject * obj0 = 0 ;
11397 PyObject * obj1 = 0 ;
11398 PyObject * obj2 = 0 ;
11399 PyObject * obj3 = 0 ;
11400 char *kwnames[] = {
11401 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11402 };
11403
11404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11406 if (SWIG_arg_fail(1)) SWIG_fail;
11407 {
11408 arg2 = (int)(SWIG_As_int(obj1));
11409 if (SWIG_arg_fail(2)) SWIG_fail;
11410 }
11411 {
11412 arg3 = (int)(SWIG_As_int(obj2));
11413 if (SWIG_arg_fail(3)) SWIG_fail;
11414 }
11415 {
11416 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11417 if (SWIG_arg_fail(4)) SWIG_fail;
11418 }
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 (arg1)->SetAlpha(arg2,arg3,arg4);
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 Py_INCREF(Py_None); resultobj = Py_None;
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj;
11435 wxImage *arg1 = (wxImage *) 0 ;
11436 int arg2 ;
11437 int arg3 ;
11438 byte result;
11439 PyObject * obj0 = 0 ;
11440 PyObject * obj1 = 0 ;
11441 PyObject * obj2 = 0 ;
11442 char *kwnames[] = {
11443 (char *) "self",(char *) "x",(char *) "y", NULL
11444 };
11445
11446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11448 if (SWIG_arg_fail(1)) SWIG_fail;
11449 {
11450 arg2 = (int)(SWIG_As_int(obj1));
11451 if (SWIG_arg_fail(2)) SWIG_fail;
11452 }
11453 {
11454 arg3 = (int)(SWIG_As_int(obj2));
11455 if (SWIG_arg_fail(3)) SWIG_fail;
11456 }
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxImage *arg1 = (wxImage *) 0 ;
11476 bool result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (bool)(arg1)->HasAlpha();
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxImage *arg1 = (wxImage *) 0 ;
11504 PyObject * obj0 = 0 ;
11505 char *kwnames[] = {
11506 (char *) "self", NULL
11507 };
11508
11509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11511 if (SWIG_arg_fail(1)) SWIG_fail;
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 (arg1)->InitAlpha();
11515
11516 wxPyEndAllowThreads(__tstate);
11517 if (PyErr_Occurred()) SWIG_fail;
11518 }
11519 Py_INCREF(Py_None); resultobj = Py_None;
11520 return resultobj;
11521 fail:
11522 return NULL;
11523 }
11524
11525
11526 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11527 PyObject *resultobj;
11528 wxImage *arg1 = (wxImage *) 0 ;
11529 int arg2 ;
11530 int arg3 ;
11531 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11532 bool result;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 PyObject * obj2 = 0 ;
11536 PyObject * obj3 = 0 ;
11537 char *kwnames[] = {
11538 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11539 };
11540
11541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11543 if (SWIG_arg_fail(1)) SWIG_fail;
11544 {
11545 arg2 = (int)(SWIG_As_int(obj1));
11546 if (SWIG_arg_fail(2)) SWIG_fail;
11547 }
11548 {
11549 arg3 = (int)(SWIG_As_int(obj2));
11550 if (SWIG_arg_fail(3)) SWIG_fail;
11551 }
11552 if (obj3) {
11553 {
11554 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11555 if (SWIG_arg_fail(4)) SWIG_fail;
11556 }
11557 }
11558 {
11559 PyThreadState* __tstate = wxPyBeginAllowThreads();
11560 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11561
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11567 }
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxImage *arg1 = (wxImage *) 0 ;
11577 byte *arg2 = (byte *) 0 ;
11578 byte *arg3 = (byte *) 0 ;
11579 byte *arg4 = (byte *) 0 ;
11580 byte arg5 = (byte) 0 ;
11581 byte arg6 = (byte) 0 ;
11582 byte arg7 = (byte) 0 ;
11583 bool result;
11584 byte temp2 ;
11585 int res2 = 0 ;
11586 byte temp3 ;
11587 int res3 = 0 ;
11588 byte temp4 ;
11589 int res4 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 PyObject * obj1 = 0 ;
11592 PyObject * obj2 = 0 ;
11593 PyObject * obj3 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11596 };
11597
11598 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11599 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11600 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11603 if (SWIG_arg_fail(1)) SWIG_fail;
11604 if (obj1) {
11605 {
11606 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11607 if (SWIG_arg_fail(5)) SWIG_fail;
11608 }
11609 }
11610 if (obj2) {
11611 {
11612 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11613 if (SWIG_arg_fail(6)) SWIG_fail;
11614 }
11615 }
11616 if (obj3) {
11617 {
11618 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11619 if (SWIG_arg_fail(7)) SWIG_fail;
11620 }
11621 }
11622 {
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11625
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 {
11630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11631 }
11632 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11633 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11634 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11635 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11636 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11637 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj;
11646 wxImage *arg1 = (wxImage *) 0 ;
11647 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11648 bool result;
11649 PyObject * obj0 = 0 ;
11650 PyObject * obj1 = 0 ;
11651 char *kwnames[] = {
11652 (char *) "self",(char *) "threshold", NULL
11653 };
11654
11655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11657 if (SWIG_arg_fail(1)) SWIG_fail;
11658 if (obj1) {
11659 {
11660 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11661 if (SWIG_arg_fail(2)) SWIG_fail;
11662 }
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11667
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj;
11682 wxImage *arg1 = (wxImage *) 0 ;
11683 byte arg2 ;
11684 byte arg3 ;
11685 byte arg4 ;
11686 bool result;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 PyObject * obj2 = 0 ;
11690 PyObject * obj3 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11697 if (SWIG_arg_fail(1)) SWIG_fail;
11698 {
11699 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11700 if (SWIG_arg_fail(2)) SWIG_fail;
11701 }
11702 {
11703 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11704 if (SWIG_arg_fail(3)) SWIG_fail;
11705 }
11706 {
11707 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11708 if (SWIG_arg_fail(4)) SWIG_fail;
11709 }
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11719 }
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj;
11728 wxImage *arg1 = (wxImage *) 0 ;
11729 wxImage *arg2 = 0 ;
11730 byte arg3 ;
11731 byte arg4 ;
11732 byte arg5 ;
11733 bool result;
11734 PyObject * obj0 = 0 ;
11735 PyObject * obj1 = 0 ;
11736 PyObject * obj2 = 0 ;
11737 PyObject * obj3 = 0 ;
11738 PyObject * obj4 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11748 if (SWIG_arg_fail(2)) SWIG_fail;
11749 if (arg2 == NULL) {
11750 SWIG_null_ref("wxImage");
11751 }
11752 if (SWIG_arg_fail(2)) SWIG_fail;
11753 }
11754 {
11755 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11756 if (SWIG_arg_fail(3)) SWIG_fail;
11757 }
11758 {
11759 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11760 if (SWIG_arg_fail(4)) SWIG_fail;
11761 }
11762 {
11763 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11764 if (SWIG_arg_fail(5)) SWIG_fail;
11765 }
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11769
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj;
11784 wxString *arg1 = 0 ;
11785 bool result;
11786 bool temp1 = false ;
11787 PyObject * obj0 = 0 ;
11788 char *kwnames[] = {
11789 (char *) "filename", NULL
11790 };
11791
11792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11793 {
11794 arg1 = wxString_in_helper(obj0);
11795 if (arg1 == NULL) SWIG_fail;
11796 temp1 = true;
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11801
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11807 }
11808 {
11809 if (temp1)
11810 delete arg1;
11811 }
11812 return resultobj;
11813 fail:
11814 {
11815 if (temp1)
11816 delete arg1;
11817 }
11818 return NULL;
11819 }
11820
11821
11822 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11823 PyObject *resultobj;
11824 wxString *arg1 = 0 ;
11825 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11826 int result;
11827 bool temp1 = false ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char *kwnames[] = {
11831 (char *) "filename",(char *) "type", NULL
11832 };
11833
11834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11835 {
11836 arg1 = wxString_in_helper(obj0);
11837 if (arg1 == NULL) SWIG_fail;
11838 temp1 = true;
11839 }
11840 if (obj1) {
11841 {
11842 arg2 = (long)(SWIG_As_long(obj1));
11843 if (SWIG_arg_fail(2)) SWIG_fail;
11844 }
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11849
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 {
11854 resultobj = SWIG_From_int((int)(result));
11855 }
11856 {
11857 if (temp1)
11858 delete arg1;
11859 }
11860 return resultobj;
11861 fail:
11862 {
11863 if (temp1)
11864 delete arg1;
11865 }
11866 return NULL;
11867 }
11868
11869
11870 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11871 PyObject *resultobj;
11872 wxImage *arg1 = (wxImage *) 0 ;
11873 wxString *arg2 = 0 ;
11874 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11875 int arg4 = (int) -1 ;
11876 bool result;
11877 bool temp2 = false ;
11878 PyObject * obj0 = 0 ;
11879 PyObject * obj1 = 0 ;
11880 PyObject * obj2 = 0 ;
11881 PyObject * obj3 = 0 ;
11882 char *kwnames[] = {
11883 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11884 };
11885
11886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11888 if (SWIG_arg_fail(1)) SWIG_fail;
11889 {
11890 arg2 = wxString_in_helper(obj1);
11891 if (arg2 == NULL) SWIG_fail;
11892 temp2 = true;
11893 }
11894 if (obj2) {
11895 {
11896 arg3 = (long)(SWIG_As_long(obj2));
11897 if (SWIG_arg_fail(3)) SWIG_fail;
11898 }
11899 }
11900 if (obj3) {
11901 {
11902 arg4 = (int)(SWIG_As_int(obj3));
11903 if (SWIG_arg_fail(4)) SWIG_fail;
11904 }
11905 }
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11915 }
11916 {
11917 if (temp2)
11918 delete arg2;
11919 }
11920 return resultobj;
11921 fail:
11922 {
11923 if (temp2)
11924 delete arg2;
11925 }
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj;
11932 wxImage *arg1 = (wxImage *) 0 ;
11933 wxString *arg2 = 0 ;
11934 wxString *arg3 = 0 ;
11935 int arg4 = (int) -1 ;
11936 bool result;
11937 bool temp2 = false ;
11938 bool temp3 = false ;
11939 PyObject * obj0 = 0 ;
11940 PyObject * obj1 = 0 ;
11941 PyObject * obj2 = 0 ;
11942 PyObject * obj3 = 0 ;
11943 char *kwnames[] = {
11944 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11945 };
11946
11947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11949 if (SWIG_arg_fail(1)) SWIG_fail;
11950 {
11951 arg2 = wxString_in_helper(obj1);
11952 if (arg2 == NULL) SWIG_fail;
11953 temp2 = true;
11954 }
11955 {
11956 arg3 = wxString_in_helper(obj2);
11957 if (arg3 == NULL) SWIG_fail;
11958 temp3 = true;
11959 }
11960 if (obj3) {
11961 {
11962 arg4 = (int)(SWIG_As_int(obj3));
11963 if (SWIG_arg_fail(4)) SWIG_fail;
11964 }
11965 }
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11969
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 {
11974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11975 }
11976 {
11977 if (temp2)
11978 delete arg2;
11979 }
11980 {
11981 if (temp3)
11982 delete arg3;
11983 }
11984 return resultobj;
11985 fail:
11986 {
11987 if (temp2)
11988 delete arg2;
11989 }
11990 {
11991 if (temp3)
11992 delete arg3;
11993 }
11994 return NULL;
11995 }
11996
11997
11998 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj;
12000 wxImage *arg1 = (wxImage *) 0 ;
12001 wxString *arg2 = 0 ;
12002 int arg3 ;
12003 bool result;
12004 bool temp2 = false ;
12005 PyObject * obj0 = 0 ;
12006 PyObject * obj1 = 0 ;
12007 PyObject * obj2 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self",(char *) "name",(char *) "type", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 arg2 = wxString_in_helper(obj1);
12017 if (arg2 == NULL) SWIG_fail;
12018 temp2 = true;
12019 }
12020 {
12021 arg3 = (int)(SWIG_As_int(obj2));
12022 if (SWIG_arg_fail(3)) SWIG_fail;
12023 }
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12033 }
12034 {
12035 if (temp2)
12036 delete arg2;
12037 }
12038 return resultobj;
12039 fail:
12040 {
12041 if (temp2)
12042 delete arg2;
12043 }
12044 return NULL;
12045 }
12046
12047
12048 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12049 PyObject *resultobj;
12050 wxImage *arg1 = (wxImage *) 0 ;
12051 wxString *arg2 = 0 ;
12052 wxString *arg3 = 0 ;
12053 bool result;
12054 bool temp2 = false ;
12055 bool temp3 = false ;
12056 PyObject * obj0 = 0 ;
12057 PyObject * obj1 = 0 ;
12058 PyObject * obj2 = 0 ;
12059 char *kwnames[] = {
12060 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12061 };
12062
12063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12065 if (SWIG_arg_fail(1)) SWIG_fail;
12066 {
12067 arg2 = wxString_in_helper(obj1);
12068 if (arg2 == NULL) SWIG_fail;
12069 temp2 = true;
12070 }
12071 {
12072 arg3 = wxString_in_helper(obj2);
12073 if (arg3 == NULL) SWIG_fail;
12074 temp3 = true;
12075 }
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 {
12084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12085 }
12086 {
12087 if (temp2)
12088 delete arg2;
12089 }
12090 {
12091 if (temp3)
12092 delete arg3;
12093 }
12094 return resultobj;
12095 fail:
12096 {
12097 if (temp2)
12098 delete arg2;
12099 }
12100 {
12101 if (temp3)
12102 delete arg3;
12103 }
12104 return NULL;
12105 }
12106
12107
12108 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12109 PyObject *resultobj;
12110 wxInputStream *arg1 = 0 ;
12111 bool result;
12112 wxPyInputStream *temp1 ;
12113 bool created1 ;
12114 PyObject * obj0 = 0 ;
12115 char *kwnames[] = {
12116 (char *) "stream", NULL
12117 };
12118
12119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12120 {
12121 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12122 arg1 = temp1->m_wxis;
12123 created1 = false;
12124 } else {
12125 PyErr_Clear(); // clear the failure of the wxPyConvert above
12126 arg1 = wxPyCBInputStream_create(obj0, false);
12127 if (arg1 == NULL) {
12128 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12129 SWIG_fail;
12130 }
12131 created1 = true;
12132 }
12133 }
12134 {
12135 PyThreadState* __tstate = wxPyBeginAllowThreads();
12136 result = (bool)wxImage::CanRead(*arg1);
12137
12138 wxPyEndAllowThreads(__tstate);
12139 if (PyErr_Occurred()) SWIG_fail;
12140 }
12141 {
12142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12143 }
12144 {
12145 if (created1) delete arg1;
12146 }
12147 return resultobj;
12148 fail:
12149 {
12150 if (created1) delete arg1;
12151 }
12152 return NULL;
12153 }
12154
12155
12156 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj;
12158 wxImage *arg1 = (wxImage *) 0 ;
12159 wxInputStream *arg2 = 0 ;
12160 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12161 int arg4 = (int) -1 ;
12162 bool result;
12163 wxPyInputStream *temp2 ;
12164 bool created2 ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 PyObject * obj2 = 0 ;
12168 PyObject * obj3 = 0 ;
12169 char *kwnames[] = {
12170 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12171 };
12172
12173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12175 if (SWIG_arg_fail(1)) SWIG_fail;
12176 {
12177 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12178 arg2 = temp2->m_wxis;
12179 created2 = false;
12180 } else {
12181 PyErr_Clear(); // clear the failure of the wxPyConvert above
12182 arg2 = wxPyCBInputStream_create(obj1, false);
12183 if (arg2 == NULL) {
12184 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12185 SWIG_fail;
12186 }
12187 created2 = true;
12188 }
12189 }
12190 if (obj2) {
12191 {
12192 arg3 = (long)(SWIG_As_long(obj2));
12193 if (SWIG_arg_fail(3)) SWIG_fail;
12194 }
12195 }
12196 if (obj3) {
12197 {
12198 arg4 = (int)(SWIG_As_int(obj3));
12199 if (SWIG_arg_fail(4)) SWIG_fail;
12200 }
12201 }
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12211 }
12212 {
12213 if (created2) delete arg2;
12214 }
12215 return resultobj;
12216 fail:
12217 {
12218 if (created2) delete arg2;
12219 }
12220 return NULL;
12221 }
12222
12223
12224 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12225 PyObject *resultobj;
12226 wxImage *arg1 = (wxImage *) 0 ;
12227 wxInputStream *arg2 = 0 ;
12228 wxString *arg3 = 0 ;
12229 int arg4 = (int) -1 ;
12230 bool result;
12231 wxPyInputStream *temp2 ;
12232 bool created2 ;
12233 bool temp3 = false ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 PyObject * obj2 = 0 ;
12237 PyObject * obj3 = 0 ;
12238 char *kwnames[] = {
12239 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12240 };
12241
12242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12244 if (SWIG_arg_fail(1)) SWIG_fail;
12245 {
12246 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12247 arg2 = temp2->m_wxis;
12248 created2 = false;
12249 } else {
12250 PyErr_Clear(); // clear the failure of the wxPyConvert above
12251 arg2 = wxPyCBInputStream_create(obj1, false);
12252 if (arg2 == NULL) {
12253 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12254 SWIG_fail;
12255 }
12256 created2 = true;
12257 }
12258 }
12259 {
12260 arg3 = wxString_in_helper(obj2);
12261 if (arg3 == NULL) SWIG_fail;
12262 temp3 = true;
12263 }
12264 if (obj3) {
12265 {
12266 arg4 = (int)(SWIG_As_int(obj3));
12267 if (SWIG_arg_fail(4)) SWIG_fail;
12268 }
12269 }
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12273
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 {
12278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12279 }
12280 {
12281 if (created2) delete arg2;
12282 }
12283 {
12284 if (temp3)
12285 delete arg3;
12286 }
12287 return resultobj;
12288 fail:
12289 {
12290 if (created2) delete arg2;
12291 }
12292 {
12293 if (temp3)
12294 delete arg3;
12295 }
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj;
12302 wxImage *arg1 = (wxImage *) 0 ;
12303 bool result;
12304 PyObject * obj0 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (bool)(arg1)->Ok();
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12321 }
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj;
12330 wxImage *arg1 = (wxImage *) 0 ;
12331 int result;
12332 PyObject * obj0 = 0 ;
12333 char *kwnames[] = {
12334 (char *) "self", NULL
12335 };
12336
12337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12339 if (SWIG_arg_fail(1)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (int)(arg1)->GetWidth();
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = SWIG_From_int((int)(result));
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj;
12358 wxImage *arg1 = (wxImage *) 0 ;
12359 int result;
12360 PyObject * obj0 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 result = (int)(arg1)->GetHeight();
12371
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 {
12376 resultobj = SWIG_From_int((int)(result));
12377 }
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxImage *arg1 = (wxImage *) 0 ;
12387 wxSize result;
12388 PyObject * obj0 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = wxImage_GetSize(arg1);
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 {
12404 wxSize * resultptr;
12405 resultptr = new wxSize((wxSize &)(result));
12406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12407 }
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj;
12416 wxImage *arg1 = (wxImage *) 0 ;
12417 wxRect *arg2 = 0 ;
12418 SwigValueWrapper<wxImage > result;
12419 wxRect temp2 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 char *kwnames[] = {
12423 (char *) "self",(char *) "rect", NULL
12424 };
12425
12426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12428 if (SWIG_arg_fail(1)) SWIG_fail;
12429 {
12430 arg2 = &temp2;
12431 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12432 }
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 wxImage * resultptr;
12442 resultptr = new wxImage((wxImage &)(result));
12443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxImage *arg1 = (wxImage *) 0 ;
12454 wxSize *arg2 = 0 ;
12455 wxPoint *arg3 = 0 ;
12456 int arg4 = (int) -1 ;
12457 int arg5 = (int) -1 ;
12458 int arg6 = (int) -1 ;
12459 SwigValueWrapper<wxImage > result;
12460 wxSize temp2 ;
12461 wxPoint temp3 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 PyObject * obj3 = 0 ;
12466 PyObject * obj4 = 0 ;
12467 PyObject * obj5 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 arg2 = &temp2;
12477 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12478 }
12479 {
12480 arg3 = &temp3;
12481 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12482 }
12483 if (obj3) {
12484 {
12485 arg4 = (int)(SWIG_As_int(obj3));
12486 if (SWIG_arg_fail(4)) SWIG_fail;
12487 }
12488 }
12489 if (obj4) {
12490 {
12491 arg5 = (int)(SWIG_As_int(obj4));
12492 if (SWIG_arg_fail(5)) SWIG_fail;
12493 }
12494 }
12495 if (obj5) {
12496 {
12497 arg6 = (int)(SWIG_As_int(obj5));
12498 if (SWIG_arg_fail(6)) SWIG_fail;
12499 }
12500 }
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12504
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 wxImage * resultptr;
12510 resultptr = new wxImage((wxImage &)(result));
12511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12512 }
12513 return resultobj;
12514 fail:
12515 return NULL;
12516 }
12517
12518
12519 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj;
12521 wxImage *arg1 = (wxImage *) 0 ;
12522 SwigValueWrapper<wxImage > result;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 result = (arg1)->Copy();
12534
12535 wxPyEndAllowThreads(__tstate);
12536 if (PyErr_Occurred()) SWIG_fail;
12537 }
12538 {
12539 wxImage * resultptr;
12540 resultptr = new wxImage((wxImage &)(result));
12541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12542 }
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12550 PyObject *resultobj;
12551 wxImage *arg1 = (wxImage *) 0 ;
12552 wxImage *arg2 = 0 ;
12553 int arg3 ;
12554 int arg4 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 PyObject * obj3 = 0 ;
12559 char *kwnames[] = {
12560 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12561 };
12562
12563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(1)) SWIG_fail;
12566 {
12567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12568 if (SWIG_arg_fail(2)) SWIG_fail;
12569 if (arg2 == NULL) {
12570 SWIG_null_ref("wxImage");
12571 }
12572 if (SWIG_arg_fail(2)) SWIG_fail;
12573 }
12574 {
12575 arg3 = (int)(SWIG_As_int(obj2));
12576 if (SWIG_arg_fail(3)) SWIG_fail;
12577 }
12578 {
12579 arg4 = (int)(SWIG_As_int(obj3));
12580 if (SWIG_arg_fail(4)) SWIG_fail;
12581 }
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12585
12586 wxPyEndAllowThreads(__tstate);
12587 if (PyErr_Occurred()) SWIG_fail;
12588 }
12589 Py_INCREF(Py_None); resultobj = Py_None;
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj;
12598 wxImage *arg1 = (wxImage *) 0 ;
12599 PyObject *result;
12600 PyObject * obj0 = 0 ;
12601 char *kwnames[] = {
12602 (char *) "self", NULL
12603 };
12604
12605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12607 if (SWIG_arg_fail(1)) SWIG_fail;
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (PyObject *)wxImage_GetData(arg1);
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 resultobj = result;
12616 return resultobj;
12617 fail:
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxImage *arg1 = (wxImage *) 0 ;
12625 buffer arg2 ;
12626 int arg3 ;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "self",(char *) "data", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12635 if (SWIG_arg_fail(1)) SWIG_fail;
12636 {
12637 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12638 }
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 wxImage_SetData(arg1,arg2,arg3);
12642
12643 wxPyEndAllowThreads(__tstate);
12644 if (PyErr_Occurred()) SWIG_fail;
12645 }
12646 Py_INCREF(Py_None); resultobj = Py_None;
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12654 PyObject *resultobj;
12655 wxImage *arg1 = (wxImage *) 0 ;
12656 PyObject *result;
12657 PyObject * obj0 = 0 ;
12658 char *kwnames[] = {
12659 (char *) "self", NULL
12660 };
12661
12662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12664 if (SWIG_arg_fail(1)) SWIG_fail;
12665 {
12666 PyThreadState* __tstate = wxPyBeginAllowThreads();
12667 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12668
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 resultobj = result;
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12680 PyObject *resultobj;
12681 wxImage *arg1 = (wxImage *) 0 ;
12682 buffer arg2 ;
12683 int arg3 ;
12684 PyObject * obj0 = 0 ;
12685 PyObject * obj1 = 0 ;
12686 char *kwnames[] = {
12687 (char *) "self",(char *) "data", NULL
12688 };
12689
12690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12692 if (SWIG_arg_fail(1)) SWIG_fail;
12693 {
12694 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12695 }
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 wxImage_SetDataBuffer(arg1,arg2,arg3);
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 Py_INCREF(Py_None); resultobj = Py_None;
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12711 PyObject *resultobj;
12712 wxImage *arg1 = (wxImage *) 0 ;
12713 PyObject *result;
12714 PyObject * obj0 = 0 ;
12715 char *kwnames[] = {
12716 (char *) "self", NULL
12717 };
12718
12719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12721 if (SWIG_arg_fail(1)) SWIG_fail;
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 result = (PyObject *)wxImage_GetAlphaData(arg1);
12725
12726 wxPyEndAllowThreads(__tstate);
12727 if (PyErr_Occurred()) SWIG_fail;
12728 }
12729 resultobj = result;
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12737 PyObject *resultobj;
12738 wxImage *arg1 = (wxImage *) 0 ;
12739 buffer arg2 ;
12740 int arg3 ;
12741 PyObject * obj0 = 0 ;
12742 PyObject * obj1 = 0 ;
12743 char *kwnames[] = {
12744 (char *) "self",(char *) "alpha", NULL
12745 };
12746
12747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12749 if (SWIG_arg_fail(1)) SWIG_fail;
12750 {
12751 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12752 }
12753 {
12754 PyThreadState* __tstate = wxPyBeginAllowThreads();
12755 wxImage_SetAlphaData(arg1,arg2,arg3);
12756
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 Py_INCREF(Py_None); resultobj = Py_None;
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12768 PyObject *resultobj;
12769 wxImage *arg1 = (wxImage *) 0 ;
12770 PyObject *result;
12771 PyObject * obj0 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12782
12783 wxPyEndAllowThreads(__tstate);
12784 if (PyErr_Occurred()) SWIG_fail;
12785 }
12786 resultobj = result;
12787 return resultobj;
12788 fail:
12789 return NULL;
12790 }
12791
12792
12793 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj;
12795 wxImage *arg1 = (wxImage *) 0 ;
12796 buffer arg2 ;
12797 int arg3 ;
12798 PyObject * obj0 = 0 ;
12799 PyObject * obj1 = 0 ;
12800 char *kwnames[] = {
12801 (char *) "self",(char *) "alpha", NULL
12802 };
12803
12804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 {
12808 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12809 }
12810 {
12811 PyThreadState* __tstate = wxPyBeginAllowThreads();
12812 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12813
12814 wxPyEndAllowThreads(__tstate);
12815 if (PyErr_Occurred()) SWIG_fail;
12816 }
12817 Py_INCREF(Py_None); resultobj = Py_None;
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12825 PyObject *resultobj;
12826 wxImage *arg1 = (wxImage *) 0 ;
12827 byte arg2 ;
12828 byte arg3 ;
12829 byte arg4 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 PyObject * obj2 = 0 ;
12833 PyObject * obj3 = 0 ;
12834 char *kwnames[] = {
12835 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12836 };
12837
12838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12840 if (SWIG_arg_fail(1)) SWIG_fail;
12841 {
12842 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12843 if (SWIG_arg_fail(2)) SWIG_fail;
12844 }
12845 {
12846 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12847 if (SWIG_arg_fail(3)) SWIG_fail;
12848 }
12849 {
12850 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12851 if (SWIG_arg_fail(4)) SWIG_fail;
12852 }
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 (arg1)->SetMaskColour(arg2,arg3,arg4);
12856
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 Py_INCREF(Py_None); resultobj = Py_None;
12861 return resultobj;
12862 fail:
12863 return NULL;
12864 }
12865
12866
12867 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12868 PyObject *resultobj;
12869 wxImage *arg1 = (wxImage *) 0 ;
12870 byte *arg2 = (byte *) 0 ;
12871 byte *arg3 = (byte *) 0 ;
12872 byte *arg4 = (byte *) 0 ;
12873 byte temp2 ;
12874 int res2 = 0 ;
12875 byte temp3 ;
12876 int res3 = 0 ;
12877 byte temp4 ;
12878 int res4 = 0 ;
12879 PyObject * obj0 = 0 ;
12880 char *kwnames[] = {
12881 (char *) "self", NULL
12882 };
12883
12884 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12885 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12886 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 Py_INCREF(Py_None); resultobj = Py_None;
12898 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12899 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12900 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12901 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12902 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12903 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12911 PyObject *resultobj;
12912 wxImage *arg1 = (wxImage *) 0 ;
12913 byte result;
12914 PyObject * obj0 = 0 ;
12915 char *kwnames[] = {
12916 (char *) "self", NULL
12917 };
12918
12919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12921 if (SWIG_arg_fail(1)) SWIG_fail;
12922 {
12923 PyThreadState* __tstate = wxPyBeginAllowThreads();
12924 result = (byte)(arg1)->GetMaskRed();
12925
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 {
12930 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12931 }
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj;
12940 wxImage *arg1 = (wxImage *) 0 ;
12941 byte result;
12942 PyObject * obj0 = 0 ;
12943 char *kwnames[] = {
12944 (char *) "self", NULL
12945 };
12946
12947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12949 if (SWIG_arg_fail(1)) SWIG_fail;
12950 {
12951 PyThreadState* __tstate = wxPyBeginAllowThreads();
12952 result = (byte)(arg1)->GetMaskGreen();
12953
12954 wxPyEndAllowThreads(__tstate);
12955 if (PyErr_Occurred()) SWIG_fail;
12956 }
12957 {
12958 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12959 }
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj;
12968 wxImage *arg1 = (wxImage *) 0 ;
12969 byte result;
12970 PyObject * obj0 = 0 ;
12971 char *kwnames[] = {
12972 (char *) "self", NULL
12973 };
12974
12975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(1)) SWIG_fail;
12978 {
12979 PyThreadState* __tstate = wxPyBeginAllowThreads();
12980 result = (byte)(arg1)->GetMaskBlue();
12981
12982 wxPyEndAllowThreads(__tstate);
12983 if (PyErr_Occurred()) SWIG_fail;
12984 }
12985 {
12986 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12987 }
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxImage *arg1 = (wxImage *) 0 ;
12997 bool arg2 = (bool) true ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self",(char *) "mask", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 if (obj1) {
13008 {
13009 arg2 = (bool)(SWIG_As_bool(obj1));
13010 if (SWIG_arg_fail(2)) SWIG_fail;
13011 }
13012 }
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 (arg1)->SetMask(arg2);
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 Py_INCREF(Py_None); resultobj = Py_None;
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13028 PyObject *resultobj;
13029 wxImage *arg1 = (wxImage *) 0 ;
13030 bool result;
13031 PyObject * obj0 = 0 ;
13032 char *kwnames[] = {
13033 (char *) "self", NULL
13034 };
13035
13036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13038 if (SWIG_arg_fail(1)) SWIG_fail;
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (bool)(arg1)->HasMask();
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13048 }
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj;
13057 wxImage *arg1 = (wxImage *) 0 ;
13058 double arg2 ;
13059 wxPoint *arg3 = 0 ;
13060 bool arg4 = (bool) true ;
13061 wxPoint *arg5 = (wxPoint *) NULL ;
13062 SwigValueWrapper<wxImage > result;
13063 wxPoint temp3 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 PyObject * obj2 = 0 ;
13067 PyObject * obj3 = 0 ;
13068 PyObject * obj4 = 0 ;
13069 char *kwnames[] = {
13070 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13071 };
13072
13073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13075 if (SWIG_arg_fail(1)) SWIG_fail;
13076 {
13077 arg2 = (double)(SWIG_As_double(obj1));
13078 if (SWIG_arg_fail(2)) SWIG_fail;
13079 }
13080 {
13081 arg3 = &temp3;
13082 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13083 }
13084 if (obj3) {
13085 {
13086 arg4 = (bool)(SWIG_As_bool(obj3));
13087 if (SWIG_arg_fail(4)) SWIG_fail;
13088 }
13089 }
13090 if (obj4) {
13091 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(5)) SWIG_fail;
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13097
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 {
13102 wxImage * resultptr;
13103 resultptr = new wxImage((wxImage &)(result));
13104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13105 }
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj;
13114 wxImage *arg1 = (wxImage *) 0 ;
13115 bool arg2 = (bool) true ;
13116 SwigValueWrapper<wxImage > result;
13117 PyObject * obj0 = 0 ;
13118 PyObject * obj1 = 0 ;
13119 char *kwnames[] = {
13120 (char *) "self",(char *) "clockwise", NULL
13121 };
13122
13123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13125 if (SWIG_arg_fail(1)) SWIG_fail;
13126 if (obj1) {
13127 {
13128 arg2 = (bool)(SWIG_As_bool(obj1));
13129 if (SWIG_arg_fail(2)) SWIG_fail;
13130 }
13131 }
13132 {
13133 PyThreadState* __tstate = wxPyBeginAllowThreads();
13134 result = (arg1)->Rotate90(arg2);
13135
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 {
13140 wxImage * resultptr;
13141 resultptr = new wxImage((wxImage &)(result));
13142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13143 }
13144 return resultobj;
13145 fail:
13146 return NULL;
13147 }
13148
13149
13150 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13151 PyObject *resultobj;
13152 wxImage *arg1 = (wxImage *) 0 ;
13153 bool arg2 = (bool) true ;
13154 SwigValueWrapper<wxImage > result;
13155 PyObject * obj0 = 0 ;
13156 PyObject * obj1 = 0 ;
13157 char *kwnames[] = {
13158 (char *) "self",(char *) "horizontally", NULL
13159 };
13160
13161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13163 if (SWIG_arg_fail(1)) SWIG_fail;
13164 if (obj1) {
13165 {
13166 arg2 = (bool)(SWIG_As_bool(obj1));
13167 if (SWIG_arg_fail(2)) SWIG_fail;
13168 }
13169 }
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (arg1)->Mirror(arg2);
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 wxImage * resultptr;
13179 resultptr = new wxImage((wxImage &)(result));
13180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13181 }
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj;
13190 wxImage *arg1 = (wxImage *) 0 ;
13191 byte arg2 ;
13192 byte arg3 ;
13193 byte arg4 ;
13194 byte arg5 ;
13195 byte arg6 ;
13196 byte arg7 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 PyObject * obj2 = 0 ;
13200 PyObject * obj3 = 0 ;
13201 PyObject * obj4 = 0 ;
13202 PyObject * obj5 = 0 ;
13203 PyObject * obj6 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13213 if (SWIG_arg_fail(2)) SWIG_fail;
13214 }
13215 {
13216 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13217 if (SWIG_arg_fail(3)) SWIG_fail;
13218 }
13219 {
13220 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13221 if (SWIG_arg_fail(4)) SWIG_fail;
13222 }
13223 {
13224 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13225 if (SWIG_arg_fail(5)) SWIG_fail;
13226 }
13227 {
13228 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13229 if (SWIG_arg_fail(6)) SWIG_fail;
13230 }
13231 {
13232 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13233 if (SWIG_arg_fail(7)) SWIG_fail;
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 Py_INCREF(Py_None); resultobj = Py_None;
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxImage *arg1 = (wxImage *) 0 ;
13252 byte arg2 ;
13253 byte arg3 ;
13254 byte arg4 ;
13255 SwigValueWrapper<wxImage > result;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 PyObject * obj2 = 0 ;
13259 PyObject * obj3 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13269 if (SWIG_arg_fail(2)) SWIG_fail;
13270 }
13271 {
13272 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13273 if (SWIG_arg_fail(3)) SWIG_fail;
13274 }
13275 {
13276 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13277 if (SWIG_arg_fail(4)) SWIG_fail;
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 {
13287 wxImage * resultptr;
13288 resultptr = new wxImage((wxImage &)(result));
13289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13290 }
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj;
13299 wxImage *arg1 = (wxImage *) 0 ;
13300 wxString *arg2 = 0 ;
13301 wxString *arg3 = 0 ;
13302 bool temp2 = false ;
13303 bool temp3 = false ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 PyObject * obj2 = 0 ;
13307 char *kwnames[] = {
13308 (char *) "self",(char *) "name",(char *) "value", NULL
13309 };
13310
13311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13313 if (SWIG_arg_fail(1)) SWIG_fail;
13314 {
13315 arg2 = wxString_in_helper(obj1);
13316 if (arg2 == NULL) SWIG_fail;
13317 temp2 = true;
13318 }
13319 {
13320 arg3 = wxString_in_helper(obj2);
13321 if (arg3 == NULL) SWIG_fail;
13322 temp3 = true;
13323 }
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13327
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 Py_INCREF(Py_None); resultobj = Py_None;
13332 {
13333 if (temp2)
13334 delete arg2;
13335 }
13336 {
13337 if (temp3)
13338 delete arg3;
13339 }
13340 return resultobj;
13341 fail:
13342 {
13343 if (temp2)
13344 delete arg2;
13345 }
13346 {
13347 if (temp3)
13348 delete arg3;
13349 }
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj;
13356 wxImage *arg1 = (wxImage *) 0 ;
13357 wxString *arg2 = 0 ;
13358 int arg3 ;
13359 bool temp2 = false ;
13360 PyObject * obj0 = 0 ;
13361 PyObject * obj1 = 0 ;
13362 PyObject * obj2 = 0 ;
13363 char *kwnames[] = {
13364 (char *) "self",(char *) "name",(char *) "value", NULL
13365 };
13366
13367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13369 if (SWIG_arg_fail(1)) SWIG_fail;
13370 {
13371 arg2 = wxString_in_helper(obj1);
13372 if (arg2 == NULL) SWIG_fail;
13373 temp2 = true;
13374 }
13375 {
13376 arg3 = (int)(SWIG_As_int(obj2));
13377 if (SWIG_arg_fail(3)) SWIG_fail;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 (arg1)->SetOption((wxString const &)*arg2,arg3);
13382
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 Py_INCREF(Py_None); resultobj = Py_None;
13387 {
13388 if (temp2)
13389 delete arg2;
13390 }
13391 return resultobj;
13392 fail:
13393 {
13394 if (temp2)
13395 delete arg2;
13396 }
13397 return NULL;
13398 }
13399
13400
13401 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj;
13403 wxImage *arg1 = (wxImage *) 0 ;
13404 wxString *arg2 = 0 ;
13405 wxString result;
13406 bool temp2 = false ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "name", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 {
13417 arg2 = wxString_in_helper(obj1);
13418 if (arg2 == NULL) SWIG_fail;
13419 temp2 = true;
13420 }
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13424
13425 wxPyEndAllowThreads(__tstate);
13426 if (PyErr_Occurred()) SWIG_fail;
13427 }
13428 {
13429 #if wxUSE_UNICODE
13430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13431 #else
13432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13433 #endif
13434 }
13435 {
13436 if (temp2)
13437 delete arg2;
13438 }
13439 return resultobj;
13440 fail:
13441 {
13442 if (temp2)
13443 delete arg2;
13444 }
13445 return NULL;
13446 }
13447
13448
13449 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj;
13451 wxImage *arg1 = (wxImage *) 0 ;
13452 wxString *arg2 = 0 ;
13453 int result;
13454 bool temp2 = false ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "self",(char *) "name", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13463 if (SWIG_arg_fail(1)) SWIG_fail;
13464 {
13465 arg2 = wxString_in_helper(obj1);
13466 if (arg2 == NULL) SWIG_fail;
13467 temp2 = true;
13468 }
13469 {
13470 PyThreadState* __tstate = wxPyBeginAllowThreads();
13471 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13472
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 {
13477 resultobj = SWIG_From_int((int)(result));
13478 }
13479 {
13480 if (temp2)
13481 delete arg2;
13482 }
13483 return resultobj;
13484 fail:
13485 {
13486 if (temp2)
13487 delete arg2;
13488 }
13489 return NULL;
13490 }
13491
13492
13493 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 wxImage *arg1 = (wxImage *) 0 ;
13496 wxString *arg2 = 0 ;
13497 bool result;
13498 bool temp2 = false ;
13499 PyObject * obj0 = 0 ;
13500 PyObject * obj1 = 0 ;
13501 char *kwnames[] = {
13502 (char *) "self",(char *) "name", NULL
13503 };
13504
13505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13507 if (SWIG_arg_fail(1)) SWIG_fail;
13508 {
13509 arg2 = wxString_in_helper(obj1);
13510 if (arg2 == NULL) SWIG_fail;
13511 temp2 = true;
13512 }
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13516
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13522 }
13523 {
13524 if (temp2)
13525 delete arg2;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (temp2)
13531 delete arg2;
13532 }
13533 return NULL;
13534 }
13535
13536
13537 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj;
13539 wxImage *arg1 = (wxImage *) 0 ;
13540 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13541 unsigned long result;
13542 PyObject * obj0 = 0 ;
13543 PyObject * obj1 = 0 ;
13544 char *kwnames[] = {
13545 (char *) "self",(char *) "stopafter", NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13550 if (SWIG_arg_fail(1)) SWIG_fail;
13551 if (obj1) {
13552 {
13553 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13554 if (SWIG_arg_fail(2)) SWIG_fail;
13555 }
13556 }
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = (unsigned long)(arg1)->CountColours(arg2);
13560
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 {
13565 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13566 }
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 wxImageHistogram *arg2 = 0 ;
13577 unsigned long result;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self",(char *) "h", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 {
13588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13589 if (SWIG_arg_fail(2)) SWIG_fail;
13590 if (arg2 == NULL) {
13591 SWIG_null_ref("wxImageHistogram");
13592 }
13593 if (SWIG_arg_fail(2)) SWIG_fail;
13594 }
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13598
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 {
13603 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13604 }
13605 return resultobj;
13606 fail:
13607 return NULL;
13608 }
13609
13610
13611 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj;
13613 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13614 PyObject * obj0 = 0 ;
13615 char *kwnames[] = {
13616 (char *) "handler", NULL
13617 };
13618
13619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13621 if (SWIG_arg_fail(1)) SWIG_fail;
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 wxImage::AddHandler(arg1);
13625
13626 wxPyEndAllowThreads(__tstate);
13627 if (PyErr_Occurred()) SWIG_fail;
13628 }
13629 Py_INCREF(Py_None); resultobj = Py_None;
13630 return resultobj;
13631 fail:
13632 return NULL;
13633 }
13634
13635
13636 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13637 PyObject *resultobj;
13638 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13639 PyObject * obj0 = 0 ;
13640 char *kwnames[] = {
13641 (char *) "handler", NULL
13642 };
13643
13644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13646 if (SWIG_arg_fail(1)) SWIG_fail;
13647 {
13648 PyThreadState* __tstate = wxPyBeginAllowThreads();
13649 wxImage::InsertHandler(arg1);
13650
13651 wxPyEndAllowThreads(__tstate);
13652 if (PyErr_Occurred()) SWIG_fail;
13653 }
13654 Py_INCREF(Py_None); resultobj = Py_None;
13655 return resultobj;
13656 fail:
13657 return NULL;
13658 }
13659
13660
13661 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13662 PyObject *resultobj;
13663 wxString *arg1 = 0 ;
13664 bool result;
13665 bool temp1 = false ;
13666 PyObject * obj0 = 0 ;
13667 char *kwnames[] = {
13668 (char *) "name", NULL
13669 };
13670
13671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13672 {
13673 arg1 = wxString_in_helper(obj0);
13674 if (arg1 == NULL) SWIG_fail;
13675 temp1 = true;
13676 }
13677 {
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13680
13681 wxPyEndAllowThreads(__tstate);
13682 if (PyErr_Occurred()) SWIG_fail;
13683 }
13684 {
13685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13686 }
13687 {
13688 if (temp1)
13689 delete arg1;
13690 }
13691 return resultobj;
13692 fail:
13693 {
13694 if (temp1)
13695 delete arg1;
13696 }
13697 return NULL;
13698 }
13699
13700
13701 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13702 PyObject *resultobj;
13703 wxString result;
13704 char *kwnames[] = {
13705 NULL
13706 };
13707
13708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13709 {
13710 PyThreadState* __tstate = wxPyBeginAllowThreads();
13711 result = wxImage::GetImageExtWildcard();
13712
13713 wxPyEndAllowThreads(__tstate);
13714 if (PyErr_Occurred()) SWIG_fail;
13715 }
13716 {
13717 #if wxUSE_UNICODE
13718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13719 #else
13720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13721 #endif
13722 }
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj;
13731 wxImage *arg1 = (wxImage *) 0 ;
13732 int arg2 = (int) -1 ;
13733 wxBitmap result;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 char *kwnames[] = {
13737 (char *) "self",(char *) "depth", NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13742 if (SWIG_arg_fail(1)) SWIG_fail;
13743 if (obj1) {
13744 {
13745 arg2 = (int)(SWIG_As_int(obj1));
13746 if (SWIG_arg_fail(2)) SWIG_fail;
13747 }
13748 }
13749 {
13750 if (!wxPyCheckForApp()) SWIG_fail;
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = wxImage_ConvertToBitmap(arg1,arg2);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 wxBitmap * resultptr;
13759 resultptr = new wxBitmap((wxBitmap &)(result));
13760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13761 }
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj;
13770 wxImage *arg1 = (wxImage *) 0 ;
13771 byte arg2 ;
13772 byte arg3 ;
13773 byte arg4 ;
13774 wxBitmap result;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 PyObject * obj3 = 0 ;
13779 char *kwnames[] = {
13780 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13781 };
13782
13783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13785 if (SWIG_arg_fail(1)) SWIG_fail;
13786 {
13787 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13788 if (SWIG_arg_fail(2)) SWIG_fail;
13789 }
13790 {
13791 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13792 if (SWIG_arg_fail(3)) SWIG_fail;
13793 }
13794 {
13795 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13796 if (SWIG_arg_fail(4)) SWIG_fail;
13797 }
13798 {
13799 if (!wxPyCheckForApp()) SWIG_fail;
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 {
13807 wxBitmap * resultptr;
13808 resultptr = new wxBitmap((wxBitmap &)(result));
13809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13810 }
13811 return resultobj;
13812 fail:
13813 return NULL;
13814 }
13815
13816
13817 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13818 PyObject *obj;
13819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13820 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13821 Py_INCREF(obj);
13822 return Py_BuildValue((char *)"");
13823 }
13824 static int _wrap_NullImage_set(PyObject *) {
13825 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13826 return 1;
13827 }
13828
13829
13830 static PyObject *_wrap_NullImage_get(void) {
13831 PyObject *pyobj;
13832
13833 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13834 return pyobj;
13835 }
13836
13837
13838 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13839 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13840 return 1;
13841 }
13842
13843
13844 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13845 PyObject *pyobj;
13846
13847 {
13848 #if wxUSE_UNICODE
13849 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13850 #else
13851 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13852 #endif
13853 }
13854 return pyobj;
13855 }
13856
13857
13858 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13859 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13860 return 1;
13861 }
13862
13863
13864 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13865 PyObject *pyobj;
13866
13867 {
13868 #if wxUSE_UNICODE
13869 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13870 #else
13871 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13872 #endif
13873 }
13874 return pyobj;
13875 }
13876
13877
13878 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13879 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13880 return 1;
13881 }
13882
13883
13884 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13885 PyObject *pyobj;
13886
13887 {
13888 #if wxUSE_UNICODE
13889 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13890 #else
13891 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13892 #endif
13893 }
13894 return pyobj;
13895 }
13896
13897
13898 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13899 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13900 return 1;
13901 }
13902
13903
13904 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13905 PyObject *pyobj;
13906
13907 {
13908 #if wxUSE_UNICODE
13909 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13910 #else
13911 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13912 #endif
13913 }
13914 return pyobj;
13915 }
13916
13917
13918 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13919 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13920 return 1;
13921 }
13922
13923
13924 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13925 PyObject *pyobj;
13926
13927 {
13928 #if wxUSE_UNICODE
13929 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13930 #else
13931 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13932 #endif
13933 }
13934 return pyobj;
13935 }
13936
13937
13938 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13939 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13940 return 1;
13941 }
13942
13943
13944 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13945 PyObject *pyobj;
13946
13947 {
13948 #if wxUSE_UNICODE
13949 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13950 #else
13951 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13952 #endif
13953 }
13954 return pyobj;
13955 }
13956
13957
13958 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13959 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13960 return 1;
13961 }
13962
13963
13964 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13965 PyObject *pyobj;
13966
13967 {
13968 #if wxUSE_UNICODE
13969 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13970 #else
13971 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13972 #endif
13973 }
13974 return pyobj;
13975 }
13976
13977
13978 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13979 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13980 return 1;
13981 }
13982
13983
13984 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13985 PyObject *pyobj;
13986
13987 {
13988 #if wxUSE_UNICODE
13989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13990 #else
13991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13992 #endif
13993 }
13994 return pyobj;
13995 }
13996
13997
13998 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13999 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14000 return 1;
14001 }
14002
14003
14004 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14005 PyObject *pyobj;
14006
14007 {
14008 #if wxUSE_UNICODE
14009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14010 #else
14011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14012 #endif
14013 }
14014 return pyobj;
14015 }
14016
14017
14018 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14019 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14020 return 1;
14021 }
14022
14023
14024 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14025 PyObject *pyobj;
14026
14027 {
14028 #if wxUSE_UNICODE
14029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14030 #else
14031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14032 #endif
14033 }
14034 return pyobj;
14035 }
14036
14037
14038 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14039 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14040 return 1;
14041 }
14042
14043
14044 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14045 PyObject *pyobj;
14046
14047 {
14048 #if wxUSE_UNICODE
14049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14050 #else
14051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14052 #endif
14053 }
14054 return pyobj;
14055 }
14056
14057
14058 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14059 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14060 return 1;
14061 }
14062
14063
14064 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14065 PyObject *pyobj;
14066
14067 {
14068 #if wxUSE_UNICODE
14069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14070 #else
14071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14072 #endif
14073 }
14074 return pyobj;
14075 }
14076
14077
14078 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14079 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14080 return 1;
14081 }
14082
14083
14084 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14085 PyObject *pyobj;
14086
14087 {
14088 #if wxUSE_UNICODE
14089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14090 #else
14091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14092 #endif
14093 }
14094 return pyobj;
14095 }
14096
14097
14098 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14099 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14100 return 1;
14101 }
14102
14103
14104 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14105 PyObject *pyobj;
14106
14107 {
14108 #if wxUSE_UNICODE
14109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14110 #else
14111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14112 #endif
14113 }
14114 return pyobj;
14115 }
14116
14117
14118 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14119 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14120 return 1;
14121 }
14122
14123
14124 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14125 PyObject *pyobj;
14126
14127 {
14128 #if wxUSE_UNICODE
14129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14130 #else
14131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14132 #endif
14133 }
14134 return pyobj;
14135 }
14136
14137
14138 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxBMPHandler *result;
14141 char *kwnames[] = {
14142 NULL
14143 };
14144
14145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (wxBMPHandler *)new wxBMPHandler();
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14161 PyObject *obj;
14162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14163 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14164 Py_INCREF(obj);
14165 return Py_BuildValue((char *)"");
14166 }
14167 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14168 PyObject *resultobj;
14169 wxICOHandler *result;
14170 char *kwnames[] = {
14171 NULL
14172 };
14173
14174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (wxICOHandler *)new wxICOHandler();
14178
14179 wxPyEndAllowThreads(__tstate);
14180 if (PyErr_Occurred()) SWIG_fail;
14181 }
14182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14183 return resultobj;
14184 fail:
14185 return NULL;
14186 }
14187
14188
14189 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14190 PyObject *obj;
14191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14192 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14193 Py_INCREF(obj);
14194 return Py_BuildValue((char *)"");
14195 }
14196 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxCURHandler *result;
14199 char *kwnames[] = {
14200 NULL
14201 };
14202
14203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14204 {
14205 PyThreadState* __tstate = wxPyBeginAllowThreads();
14206 result = (wxCURHandler *)new wxCURHandler();
14207
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14219 PyObject *obj;
14220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14221 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14222 Py_INCREF(obj);
14223 return Py_BuildValue((char *)"");
14224 }
14225 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj;
14227 wxANIHandler *result;
14228 char *kwnames[] = {
14229 NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (wxANIHandler *)new wxANIHandler();
14236
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14248 PyObject *obj;
14249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14250 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14251 Py_INCREF(obj);
14252 return Py_BuildValue((char *)"");
14253 }
14254 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxPNGHandler *result;
14257 char *kwnames[] = {
14258 NULL
14259 };
14260
14261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (wxPNGHandler *)new wxPNGHandler();
14265
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14277 PyObject *obj;
14278 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14279 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14280 Py_INCREF(obj);
14281 return Py_BuildValue((char *)"");
14282 }
14283 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj;
14285 wxGIFHandler *result;
14286 char *kwnames[] = {
14287 NULL
14288 };
14289
14290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (wxGIFHandler *)new wxGIFHandler();
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14306 PyObject *obj;
14307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14308 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14309 Py_INCREF(obj);
14310 return Py_BuildValue((char *)"");
14311 }
14312 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14313 PyObject *resultobj;
14314 wxPCXHandler *result;
14315 char *kwnames[] = {
14316 NULL
14317 };
14318
14319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14320 {
14321 PyThreadState* __tstate = wxPyBeginAllowThreads();
14322 result = (wxPCXHandler *)new wxPCXHandler();
14323
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14335 PyObject *obj;
14336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14337 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14338 Py_INCREF(obj);
14339 return Py_BuildValue((char *)"");
14340 }
14341 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxJPEGHandler *result;
14344 char *kwnames[] = {
14345 NULL
14346 };
14347
14348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (wxJPEGHandler *)new wxJPEGHandler();
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14364 PyObject *obj;
14365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14366 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14367 Py_INCREF(obj);
14368 return Py_BuildValue((char *)"");
14369 }
14370 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14371 PyObject *resultobj;
14372 wxPNMHandler *result;
14373 char *kwnames[] = {
14374 NULL
14375 };
14376
14377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (wxPNMHandler *)new wxPNMHandler();
14381
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14393 PyObject *obj;
14394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14395 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14396 Py_INCREF(obj);
14397 return Py_BuildValue((char *)"");
14398 }
14399 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14400 PyObject *resultobj;
14401 wxXPMHandler *result;
14402 char *kwnames[] = {
14403 NULL
14404 };
14405
14406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = (wxXPMHandler *)new wxXPMHandler();
14410
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14422 PyObject *obj;
14423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14424 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14425 Py_INCREF(obj);
14426 return Py_BuildValue((char *)"");
14427 }
14428 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14429 PyObject *resultobj;
14430 wxTIFFHandler *result;
14431 char *kwnames[] = {
14432 NULL
14433 };
14434
14435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14436 {
14437 PyThreadState* __tstate = wxPyBeginAllowThreads();
14438 result = (wxTIFFHandler *)new wxTIFFHandler();
14439
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14444 return resultobj;
14445 fail:
14446 return NULL;
14447 }
14448
14449
14450 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14451 PyObject *obj;
14452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14453 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14454 Py_INCREF(obj);
14455 return Py_BuildValue((char *)"");
14456 }
14457 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj;
14459 wxImage *arg1 = 0 ;
14460 wxImage *arg2 = 0 ;
14461 int arg3 = (int) 236 ;
14462 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14463 bool result;
14464 PyObject * obj0 = 0 ;
14465 PyObject * obj1 = 0 ;
14466 PyObject * obj2 = 0 ;
14467 PyObject * obj3 = 0 ;
14468 char *kwnames[] = {
14469 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14470 };
14471
14472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14473 {
14474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14475 if (SWIG_arg_fail(1)) SWIG_fail;
14476 if (arg1 == NULL) {
14477 SWIG_null_ref("wxImage");
14478 }
14479 if (SWIG_arg_fail(1)) SWIG_fail;
14480 }
14481 {
14482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14483 if (SWIG_arg_fail(2)) SWIG_fail;
14484 if (arg2 == NULL) {
14485 SWIG_null_ref("wxImage");
14486 }
14487 if (SWIG_arg_fail(2)) SWIG_fail;
14488 }
14489 if (obj2) {
14490 {
14491 arg3 = (int)(SWIG_As_int(obj2));
14492 if (SWIG_arg_fail(3)) SWIG_fail;
14493 }
14494 }
14495 if (obj3) {
14496 {
14497 arg4 = (int)(SWIG_As_int(obj3));
14498 if (SWIG_arg_fail(4)) SWIG_fail;
14499 }
14500 }
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14518 PyObject *obj;
14519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14520 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14521 Py_INCREF(obj);
14522 return Py_BuildValue((char *)"");
14523 }
14524 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj;
14526 wxEvtHandler *result;
14527 char *kwnames[] = {
14528 NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14532 {
14533 PyThreadState* __tstate = wxPyBeginAllowThreads();
14534 result = (wxEvtHandler *)new wxEvtHandler();
14535
14536 wxPyEndAllowThreads(__tstate);
14537 if (PyErr_Occurred()) SWIG_fail;
14538 }
14539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14549 wxEvtHandler *result;
14550 PyObject * obj0 = 0 ;
14551 char *kwnames[] = {
14552 (char *) "self", NULL
14553 };
14554
14555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14557 if (SWIG_arg_fail(1)) SWIG_fail;
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = wxPyMake_wxObject(result, 0);
14567 }
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj;
14576 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14577 wxEvtHandler *result;
14578 PyObject * obj0 = 0 ;
14579 char *kwnames[] = {
14580 (char *) "self", NULL
14581 };
14582
14583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14585 if (SWIG_arg_fail(1)) SWIG_fail;
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14589
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 {
14594 resultobj = wxPyMake_wxObject(result, 0);
14595 }
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj;
14604 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14605 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14606 PyObject * obj0 = 0 ;
14607 PyObject * obj1 = 0 ;
14608 char *kwnames[] = {
14609 (char *) "self",(char *) "handler", NULL
14610 };
14611
14612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14614 if (SWIG_arg_fail(1)) SWIG_fail;
14615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14616 if (SWIG_arg_fail(2)) SWIG_fail;
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 (arg1)->SetNextHandler(arg2);
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 Py_INCREF(Py_None); resultobj = Py_None;
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj;
14633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14635 PyObject * obj0 = 0 ;
14636 PyObject * obj1 = 0 ;
14637 char *kwnames[] = {
14638 (char *) "self",(char *) "handler", NULL
14639 };
14640
14641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14643 if (SWIG_arg_fail(1)) SWIG_fail;
14644 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14645 if (SWIG_arg_fail(2)) SWIG_fail;
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 (arg1)->SetPreviousHandler(arg2);
14649
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 Py_INCREF(Py_None); resultobj = Py_None;
14654 return resultobj;
14655 fail:
14656 return NULL;
14657 }
14658
14659
14660 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14661 PyObject *resultobj;
14662 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14663 bool result;
14664 PyObject * obj0 = 0 ;
14665 char *kwnames[] = {
14666 (char *) "self", NULL
14667 };
14668
14669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14671 if (SWIG_arg_fail(1)) SWIG_fail;
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (bool)(arg1)->GetEvtHandlerEnabled();
14675
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 {
14680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14681 }
14682 return resultobj;
14683 fail:
14684 return NULL;
14685 }
14686
14687
14688 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14689 PyObject *resultobj;
14690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14691 bool arg2 ;
14692 PyObject * obj0 = 0 ;
14693 PyObject * obj1 = 0 ;
14694 char *kwnames[] = {
14695 (char *) "self",(char *) "enabled", NULL
14696 };
14697
14698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14700 if (SWIG_arg_fail(1)) SWIG_fail;
14701 {
14702 arg2 = (bool)(SWIG_As_bool(obj1));
14703 if (SWIG_arg_fail(2)) SWIG_fail;
14704 }
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 (arg1)->SetEvtHandlerEnabled(arg2);
14708
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 Py_INCREF(Py_None); resultobj = Py_None;
14713 return resultobj;
14714 fail:
14715 return NULL;
14716 }
14717
14718
14719 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14720 PyObject *resultobj;
14721 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14722 wxEvent *arg2 = 0 ;
14723 bool result;
14724 PyObject * obj0 = 0 ;
14725 PyObject * obj1 = 0 ;
14726 char *kwnames[] = {
14727 (char *) "self",(char *) "event", NULL
14728 };
14729
14730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14732 if (SWIG_arg_fail(1)) SWIG_fail;
14733 {
14734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14735 if (SWIG_arg_fail(2)) SWIG_fail;
14736 if (arg2 == NULL) {
14737 SWIG_null_ref("wxEvent");
14738 }
14739 if (SWIG_arg_fail(2)) SWIG_fail;
14740 }
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (bool)(arg1)->ProcessEvent(*arg2);
14744
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 {
14749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14750 }
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14758 PyObject *resultobj;
14759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14760 wxEvent *arg2 = 0 ;
14761 PyObject * obj0 = 0 ;
14762 PyObject * obj1 = 0 ;
14763 char *kwnames[] = {
14764 (char *) "self",(char *) "event", NULL
14765 };
14766
14767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14769 if (SWIG_arg_fail(1)) SWIG_fail;
14770 {
14771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14772 if (SWIG_arg_fail(2)) SWIG_fail;
14773 if (arg2 == NULL) {
14774 SWIG_null_ref("wxEvent");
14775 }
14776 if (SWIG_arg_fail(2)) SWIG_fail;
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 (arg1)->AddPendingEvent(*arg2);
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 Py_INCREF(Py_None); resultobj = Py_None;
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14793 PyObject *resultobj;
14794 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14795 PyObject * obj0 = 0 ;
14796 char *kwnames[] = {
14797 (char *) "self", NULL
14798 };
14799
14800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14802 if (SWIG_arg_fail(1)) SWIG_fail;
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 (arg1)->ProcessPendingEvents();
14806
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 Py_INCREF(Py_None); resultobj = Py_None;
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14818 PyObject *resultobj;
14819 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14820 int arg2 ;
14821 int arg3 ;
14822 int arg4 ;
14823 PyObject *arg5 = (PyObject *) 0 ;
14824 PyObject * obj0 = 0 ;
14825 PyObject * obj1 = 0 ;
14826 PyObject * obj2 = 0 ;
14827 PyObject * obj3 = 0 ;
14828 PyObject * obj4 = 0 ;
14829 char *kwnames[] = {
14830 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14831 };
14832
14833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14835 if (SWIG_arg_fail(1)) SWIG_fail;
14836 {
14837 arg2 = (int)(SWIG_As_int(obj1));
14838 if (SWIG_arg_fail(2)) SWIG_fail;
14839 }
14840 {
14841 arg3 = (int)(SWIG_As_int(obj2));
14842 if (SWIG_arg_fail(3)) SWIG_fail;
14843 }
14844 {
14845 arg4 = (int)(SWIG_As_int(obj3));
14846 if (SWIG_arg_fail(4)) SWIG_fail;
14847 }
14848 arg5 = obj4;
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14852
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 Py_INCREF(Py_None); resultobj = Py_None;
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj;
14865 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14866 int arg2 ;
14867 int arg3 = (int) -1 ;
14868 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14869 bool result;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 PyObject * obj2 = 0 ;
14873 PyObject * obj3 = 0 ;
14874 char *kwnames[] = {
14875 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14876 };
14877
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14880 if (SWIG_arg_fail(1)) SWIG_fail;
14881 {
14882 arg2 = (int)(SWIG_As_int(obj1));
14883 if (SWIG_arg_fail(2)) SWIG_fail;
14884 }
14885 if (obj2) {
14886 {
14887 arg3 = (int)(SWIG_As_int(obj2));
14888 if (SWIG_arg_fail(3)) SWIG_fail;
14889 }
14890 }
14891 if (obj3) {
14892 {
14893 arg4 = (wxEventType)(SWIG_As_int(obj3));
14894 if (SWIG_arg_fail(4)) SWIG_fail;
14895 }
14896 }
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14900
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14906 }
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj;
14915 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14916 PyObject *arg2 = (PyObject *) 0 ;
14917 bool arg3 = (bool) true ;
14918 PyObject * obj0 = 0 ;
14919 PyObject * obj1 = 0 ;
14920 PyObject * obj2 = 0 ;
14921 char *kwnames[] = {
14922 (char *) "self",(char *) "_self",(char *) "incref", NULL
14923 };
14924
14925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14927 if (SWIG_arg_fail(1)) SWIG_fail;
14928 arg2 = obj1;
14929 if (obj2) {
14930 {
14931 arg3 = (bool)(SWIG_As_bool(obj2));
14932 if (SWIG_arg_fail(3)) SWIG_fail;
14933 }
14934 }
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14938
14939 wxPyEndAllowThreads(__tstate);
14940 if (PyErr_Occurred()) SWIG_fail;
14941 }
14942 Py_INCREF(Py_None); resultobj = Py_None;
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14950 PyObject *obj;
14951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14952 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14953 Py_INCREF(obj);
14954 return Py_BuildValue((char *)"");
14955 }
14956 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxEventType result;
14959 char *kwnames[] = {
14960 NULL
14961 };
14962
14963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14964 {
14965 PyThreadState* __tstate = wxPyBeginAllowThreads();
14966 result = (wxEventType)wxNewEventType();
14967
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 {
14972 resultobj = SWIG_From_int((int)(result));
14973 }
14974 return resultobj;
14975 fail:
14976 return NULL;
14977 }
14978
14979
14980 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj;
14982 wxEvent *arg1 = (wxEvent *) 0 ;
14983 PyObject * obj0 = 0 ;
14984 char *kwnames[] = {
14985 (char *) "self", NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14990 if (SWIG_arg_fail(1)) SWIG_fail;
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 delete arg1;
14994
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 Py_INCREF(Py_None); resultobj = Py_None;
14999 return resultobj;
15000 fail:
15001 return NULL;
15002 }
15003
15004
15005 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj;
15007 wxEvent *arg1 = (wxEvent *) 0 ;
15008 wxEventType arg2 ;
15009 PyObject * obj0 = 0 ;
15010 PyObject * obj1 = 0 ;
15011 char *kwnames[] = {
15012 (char *) "self",(char *) "typ", NULL
15013 };
15014
15015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15017 if (SWIG_arg_fail(1)) SWIG_fail;
15018 {
15019 arg2 = (wxEventType)(SWIG_As_int(obj1));
15020 if (SWIG_arg_fail(2)) SWIG_fail;
15021 }
15022 {
15023 PyThreadState* __tstate = wxPyBeginAllowThreads();
15024 (arg1)->SetEventType(arg2);
15025
15026 wxPyEndAllowThreads(__tstate);
15027 if (PyErr_Occurred()) SWIG_fail;
15028 }
15029 Py_INCREF(Py_None); resultobj = Py_None;
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj;
15038 wxEvent *arg1 = (wxEvent *) 0 ;
15039 wxEventType result;
15040 PyObject * obj0 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 {
15056 resultobj = SWIG_From_int((int)(result));
15057 }
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj;
15066 wxEvent *arg1 = (wxEvent *) 0 ;
15067 wxObject *result;
15068 PyObject * obj0 = 0 ;
15069 char *kwnames[] = {
15070 (char *) "self", NULL
15071 };
15072
15073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15075 if (SWIG_arg_fail(1)) SWIG_fail;
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15079
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 {
15084 resultobj = wxPyMake_wxObject(result, 0);
15085 }
15086 return resultobj;
15087 fail:
15088 return NULL;
15089 }
15090
15091
15092 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15093 PyObject *resultobj;
15094 wxEvent *arg1 = (wxEvent *) 0 ;
15095 wxObject *arg2 = (wxObject *) 0 ;
15096 PyObject * obj0 = 0 ;
15097 PyObject * obj1 = 0 ;
15098 char *kwnames[] = {
15099 (char *) "self",(char *) "obj", NULL
15100 };
15101
15102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15104 if (SWIG_arg_fail(1)) SWIG_fail;
15105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15106 if (SWIG_arg_fail(2)) SWIG_fail;
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 (arg1)->SetEventObject(arg2);
15110
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 Py_INCREF(Py_None); resultobj = Py_None;
15115 return resultobj;
15116 fail:
15117 return NULL;
15118 }
15119
15120
15121 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15122 PyObject *resultobj;
15123 wxEvent *arg1 = (wxEvent *) 0 ;
15124 long result;
15125 PyObject * obj0 = 0 ;
15126 char *kwnames[] = {
15127 (char *) "self", NULL
15128 };
15129
15130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(1)) SWIG_fail;
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 {
15141 resultobj = SWIG_From_long((long)(result));
15142 }
15143 return resultobj;
15144 fail:
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxEvent *arg1 = (wxEvent *) 0 ;
15152 long arg2 = (long) 0 ;
15153 PyObject * obj0 = 0 ;
15154 PyObject * obj1 = 0 ;
15155 char *kwnames[] = {
15156 (char *) "self",(char *) "ts", NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(1)) SWIG_fail;
15162 if (obj1) {
15163 {
15164 arg2 = (long)(SWIG_As_long(obj1));
15165 if (SWIG_arg_fail(2)) SWIG_fail;
15166 }
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 (arg1)->SetTimestamp(arg2);
15171
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 Py_INCREF(Py_None); resultobj = Py_None;
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj;
15184 wxEvent *arg1 = (wxEvent *) 0 ;
15185 int result;
15186 PyObject * obj0 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 result = (int)((wxEvent const *)arg1)->GetId();
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 {
15202 resultobj = SWIG_From_int((int)(result));
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj;
15212 wxEvent *arg1 = (wxEvent *) 0 ;
15213 int arg2 ;
15214 PyObject * obj0 = 0 ;
15215 PyObject * obj1 = 0 ;
15216 char *kwnames[] = {
15217 (char *) "self",(char *) "Id", NULL
15218 };
15219
15220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15222 if (SWIG_arg_fail(1)) SWIG_fail;
15223 {
15224 arg2 = (int)(SWIG_As_int(obj1));
15225 if (SWIG_arg_fail(2)) SWIG_fail;
15226 }
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 (arg1)->SetId(arg2);
15230
15231 wxPyEndAllowThreads(__tstate);
15232 if (PyErr_Occurred()) SWIG_fail;
15233 }
15234 Py_INCREF(Py_None); resultobj = Py_None;
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15242 PyObject *resultobj;
15243 wxEvent *arg1 = (wxEvent *) 0 ;
15244 bool result;
15245 PyObject * obj0 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 {
15261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15262 }
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15270 PyObject *resultobj;
15271 wxEvent *arg1 = (wxEvent *) 0 ;
15272 bool arg2 = (bool) true ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 char *kwnames[] = {
15276 (char *) "self",(char *) "skip", NULL
15277 };
15278
15279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(1)) SWIG_fail;
15282 if (obj1) {
15283 {
15284 arg2 = (bool)(SWIG_As_bool(obj1));
15285 if (SWIG_arg_fail(2)) SWIG_fail;
15286 }
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 (arg1)->Skip(arg2);
15291
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 Py_INCREF(Py_None); resultobj = Py_None;
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj;
15304 wxEvent *arg1 = (wxEvent *) 0 ;
15305 bool result;
15306 PyObject * obj0 = 0 ;
15307 char *kwnames[] = {
15308 (char *) "self", NULL
15309 };
15310
15311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15313 if (SWIG_arg_fail(1)) SWIG_fail;
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 {
15322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15323 }
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15331 PyObject *resultobj;
15332 wxEvent *arg1 = (wxEvent *) 0 ;
15333 bool result;
15334 PyObject * obj0 = 0 ;
15335 char *kwnames[] = {
15336 (char *) "self", NULL
15337 };
15338
15339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15341 if (SWIG_arg_fail(1)) SWIG_fail;
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15345
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 {
15350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15351 }
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15359 PyObject *resultobj;
15360 wxEvent *arg1 = (wxEvent *) 0 ;
15361 int result;
15362 PyObject * obj0 = 0 ;
15363 char *kwnames[] = {
15364 (char *) "self", NULL
15365 };
15366
15367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15369 if (SWIG_arg_fail(1)) SWIG_fail;
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->StopPropagation();
15373
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 {
15378 resultobj = SWIG_From_int((int)(result));
15379 }
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15387 PyObject *resultobj;
15388 wxEvent *arg1 = (wxEvent *) 0 ;
15389 int arg2 ;
15390 PyObject * obj0 = 0 ;
15391 PyObject * obj1 = 0 ;
15392 char *kwnames[] = {
15393 (char *) "self",(char *) "propagationLevel", NULL
15394 };
15395
15396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15398 if (SWIG_arg_fail(1)) SWIG_fail;
15399 {
15400 arg2 = (int)(SWIG_As_int(obj1));
15401 if (SWIG_arg_fail(2)) SWIG_fail;
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 (arg1)->ResumePropagation(arg2);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 Py_INCREF(Py_None); resultobj = Py_None;
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxEvent *arg1 = (wxEvent *) 0 ;
15420 wxEvent *result;
15421 PyObject * obj0 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (wxEvent *)(arg1)->Clone();
15432
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15444 PyObject *obj;
15445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15446 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15447 Py_INCREF(obj);
15448 return Py_BuildValue((char *)"");
15449 }
15450 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15451 PyObject *resultobj;
15452 wxEvent *arg1 = 0 ;
15453 wxPropagationDisabler *result;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "event", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15460 {
15461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15462 if (SWIG_arg_fail(1)) SWIG_fail;
15463 if (arg1 == NULL) {
15464 SWIG_null_ref("wxEvent");
15465 }
15466 if (SWIG_arg_fail(1)) SWIG_fail;
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15471
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15476 return resultobj;
15477 fail:
15478 return NULL;
15479 }
15480
15481
15482 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15483 PyObject *resultobj;
15484 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15485 PyObject * obj0 = 0 ;
15486 char *kwnames[] = {
15487 (char *) "self", NULL
15488 };
15489
15490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15492 if (SWIG_arg_fail(1)) SWIG_fail;
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 delete arg1;
15496
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 Py_INCREF(Py_None); resultobj = Py_None;
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15508 PyObject *obj;
15509 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15510 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15511 Py_INCREF(obj);
15512 return Py_BuildValue((char *)"");
15513 }
15514 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15515 PyObject *resultobj;
15516 wxEvent *arg1 = 0 ;
15517 wxPropagateOnce *result;
15518 PyObject * obj0 = 0 ;
15519 char *kwnames[] = {
15520 (char *) "event", NULL
15521 };
15522
15523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15524 {
15525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15526 if (SWIG_arg_fail(1)) SWIG_fail;
15527 if (arg1 == NULL) {
15528 SWIG_null_ref("wxEvent");
15529 }
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 }
15532 {
15533 PyThreadState* __tstate = wxPyBeginAllowThreads();
15534 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15535
15536 wxPyEndAllowThreads(__tstate);
15537 if (PyErr_Occurred()) SWIG_fail;
15538 }
15539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15540 return resultobj;
15541 fail:
15542 return NULL;
15543 }
15544
15545
15546 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15547 PyObject *resultobj;
15548 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15549 PyObject * obj0 = 0 ;
15550 char *kwnames[] = {
15551 (char *) "self", NULL
15552 };
15553
15554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15556 if (SWIG_arg_fail(1)) SWIG_fail;
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 delete arg1;
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 Py_INCREF(Py_None); resultobj = Py_None;
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15572 PyObject *obj;
15573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15574 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15575 Py_INCREF(obj);
15576 return Py_BuildValue((char *)"");
15577 }
15578 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15579 PyObject *resultobj;
15580 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15581 int arg2 = (int) 0 ;
15582 wxCommandEvent *result;
15583 PyObject * obj0 = 0 ;
15584 PyObject * obj1 = 0 ;
15585 char *kwnames[] = {
15586 (char *) "commandType",(char *) "winid", NULL
15587 };
15588
15589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15590 if (obj0) {
15591 {
15592 arg1 = (wxEventType)(SWIG_As_int(obj0));
15593 if (SWIG_arg_fail(1)) SWIG_fail;
15594 }
15595 }
15596 if (obj1) {
15597 {
15598 arg2 = (int)(SWIG_As_int(obj1));
15599 if (SWIG_arg_fail(2)) SWIG_fail;
15600 }
15601 }
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15605
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15619 int result;
15620 PyObject * obj0 = 0 ;
15621 char *kwnames[] = {
15622 (char *) "self", NULL
15623 };
15624
15625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15647 wxString *arg2 = 0 ;
15648 bool temp2 = false ;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 char *kwnames[] = {
15652 (char *) "self",(char *) "s", NULL
15653 };
15654
15655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15657 if (SWIG_arg_fail(1)) SWIG_fail;
15658 {
15659 arg2 = wxString_in_helper(obj1);
15660 if (arg2 == NULL) SWIG_fail;
15661 temp2 = true;
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 (arg1)->SetString((wxString const &)*arg2);
15666
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 Py_INCREF(Py_None); resultobj = Py_None;
15671 {
15672 if (temp2)
15673 delete arg2;
15674 }
15675 return resultobj;
15676 fail:
15677 {
15678 if (temp2)
15679 delete arg2;
15680 }
15681 return NULL;
15682 }
15683
15684
15685 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15686 PyObject *resultobj;
15687 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15688 wxString result;
15689 PyObject * obj0 = 0 ;
15690 char *kwnames[] = {
15691 (char *) "self", NULL
15692 };
15693
15694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15696 if (SWIG_arg_fail(1)) SWIG_fail;
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = ((wxCommandEvent const *)arg1)->GetString();
15700
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 #if wxUSE_UNICODE
15706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15707 #else
15708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15709 #endif
15710 }
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15718 PyObject *resultobj;
15719 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15720 bool result;
15721 PyObject * obj0 = 0 ;
15722 char *kwnames[] = {
15723 (char *) "self", NULL
15724 };
15725
15726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15728 if (SWIG_arg_fail(1)) SWIG_fail;
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15732
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 {
15737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15738 }
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj;
15747 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15748 bool result;
15749 PyObject * obj0 = 0 ;
15750 char *kwnames[] = {
15751 (char *) "self", NULL
15752 };
15753
15754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15756 if (SWIG_arg_fail(1)) SWIG_fail;
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15760
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15766 }
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15776 long arg2 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 char *kwnames[] = {
15780 (char *) "self",(char *) "extraLong", NULL
15781 };
15782
15783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15785 if (SWIG_arg_fail(1)) SWIG_fail;
15786 {
15787 arg2 = (long)(SWIG_As_long(obj1));
15788 if (SWIG_arg_fail(2)) SWIG_fail;
15789 }
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 (arg1)->SetExtraLong(arg2);
15793
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 Py_INCREF(Py_None); resultobj = Py_None;
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj;
15806 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15807 long result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15819
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 {
15824 resultobj = SWIG_From_long((long)(result));
15825 }
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15833 PyObject *resultobj;
15834 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15835 int arg2 ;
15836 PyObject * obj0 = 0 ;
15837 PyObject * obj1 = 0 ;
15838 char *kwnames[] = {
15839 (char *) "self",(char *) "i", NULL
15840 };
15841
15842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15844 if (SWIG_arg_fail(1)) SWIG_fail;
15845 {
15846 arg2 = (int)(SWIG_As_int(obj1));
15847 if (SWIG_arg_fail(2)) SWIG_fail;
15848 }
15849 {
15850 PyThreadState* __tstate = wxPyBeginAllowThreads();
15851 (arg1)->SetInt(arg2);
15852
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 Py_INCREF(Py_None); resultobj = Py_None;
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj;
15865 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15866 long result;
15867 PyObject * obj0 = 0 ;
15868 char *kwnames[] = {
15869 (char *) "self", NULL
15870 };
15871
15872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15874 if (SWIG_arg_fail(1)) SWIG_fail;
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15878
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 {
15883 resultobj = SWIG_From_long((long)(result));
15884 }
15885 return resultobj;
15886 fail:
15887 return NULL;
15888 }
15889
15890
15891 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj;
15893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15894 wxEvent *result;
15895 PyObject * obj0 = 0 ;
15896 char *kwnames[] = {
15897 (char *) "self", NULL
15898 };
15899
15900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15902 if (SWIG_arg_fail(1)) SWIG_fail;
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15906
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15918 PyObject *obj;
15919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15920 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15921 Py_INCREF(obj);
15922 return Py_BuildValue((char *)"");
15923 }
15924 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15925 PyObject *resultobj;
15926 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15927 int arg2 = (int) 0 ;
15928 wxNotifyEvent *result;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char *kwnames[] = {
15932 (char *) "commandType",(char *) "winid", NULL
15933 };
15934
15935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15936 if (obj0) {
15937 {
15938 arg1 = (wxEventType)(SWIG_As_int(obj0));
15939 if (SWIG_arg_fail(1)) SWIG_fail;
15940 }
15941 }
15942 if (obj1) {
15943 {
15944 arg2 = (int)(SWIG_As_int(obj1));
15945 if (SWIG_arg_fail(2)) SWIG_fail;
15946 }
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15951
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15963 PyObject *resultobj;
15964 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 (arg1)->Veto();
15976
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 Py_INCREF(Py_None); resultobj = Py_None;
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj;
15989 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15990 PyObject * obj0 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "self", NULL
15993 };
15994
15995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15997 if (SWIG_arg_fail(1)) SWIG_fail;
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 (arg1)->Allow();
16001
16002 wxPyEndAllowThreads(__tstate);
16003 if (PyErr_Occurred()) SWIG_fail;
16004 }
16005 Py_INCREF(Py_None); resultobj = Py_None;
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj;
16014 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16015 bool result;
16016 PyObject * obj0 = 0 ;
16017 char *kwnames[] = {
16018 (char *) "self", NULL
16019 };
16020
16021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16023 if (SWIG_arg_fail(1)) SWIG_fail;
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (bool)(arg1)->IsAllowed();
16027
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 {
16032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16033 }
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16041 PyObject *obj;
16042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16043 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16044 Py_INCREF(obj);
16045 return Py_BuildValue((char *)"");
16046 }
16047 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16048 PyObject *resultobj;
16049 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16050 int arg2 = (int) 0 ;
16051 int arg3 = (int) 0 ;
16052 int arg4 = (int) 0 ;
16053 wxScrollEvent *result;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 PyObject * obj2 = 0 ;
16057 PyObject * obj3 = 0 ;
16058 char *kwnames[] = {
16059 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16060 };
16061
16062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16063 if (obj0) {
16064 {
16065 arg1 = (wxEventType)(SWIG_As_int(obj0));
16066 if (SWIG_arg_fail(1)) SWIG_fail;
16067 }
16068 }
16069 if (obj1) {
16070 {
16071 arg2 = (int)(SWIG_As_int(obj1));
16072 if (SWIG_arg_fail(2)) SWIG_fail;
16073 }
16074 }
16075 if (obj2) {
16076 {
16077 arg3 = (int)(SWIG_As_int(obj2));
16078 if (SWIG_arg_fail(3)) SWIG_fail;
16079 }
16080 }
16081 if (obj3) {
16082 {
16083 arg4 = (int)(SWIG_As_int(obj3));
16084 if (SWIG_arg_fail(4)) SWIG_fail;
16085 }
16086 }
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16090
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16102 PyObject *resultobj;
16103 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16104 int result;
16105 PyObject * obj0 = 0 ;
16106 char *kwnames[] = {
16107 (char *) "self", NULL
16108 };
16109
16110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16112 if (SWIG_arg_fail(1)) SWIG_fail;
16113 {
16114 PyThreadState* __tstate = wxPyBeginAllowThreads();
16115 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16116
16117 wxPyEndAllowThreads(__tstate);
16118 if (PyErr_Occurred()) SWIG_fail;
16119 }
16120 {
16121 resultobj = SWIG_From_int((int)(result));
16122 }
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16130 PyObject *resultobj;
16131 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16132 int result;
16133 PyObject * obj0 = 0 ;
16134 char *kwnames[] = {
16135 (char *) "self", NULL
16136 };
16137
16138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16140 if (SWIG_arg_fail(1)) SWIG_fail;
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16144
16145 wxPyEndAllowThreads(__tstate);
16146 if (PyErr_Occurred()) SWIG_fail;
16147 }
16148 {
16149 resultobj = SWIG_From_int((int)(result));
16150 }
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj;
16159 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16160 int arg2 ;
16161 PyObject * obj0 = 0 ;
16162 PyObject * obj1 = 0 ;
16163 char *kwnames[] = {
16164 (char *) "self",(char *) "orient", NULL
16165 };
16166
16167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16169 if (SWIG_arg_fail(1)) SWIG_fail;
16170 {
16171 arg2 = (int)(SWIG_As_int(obj1));
16172 if (SWIG_arg_fail(2)) SWIG_fail;
16173 }
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 (arg1)->SetOrientation(arg2);
16177
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 Py_INCREF(Py_None); resultobj = Py_None;
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj;
16190 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16191 int arg2 ;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self",(char *) "pos", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 arg2 = (int)(SWIG_As_int(obj1));
16203 if (SWIG_arg_fail(2)) SWIG_fail;
16204 }
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 (arg1)->SetPosition(arg2);
16208
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 Py_INCREF(Py_None); resultobj = Py_None;
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16220 PyObject *obj;
16221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16222 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16223 Py_INCREF(obj);
16224 return Py_BuildValue((char *)"");
16225 }
16226 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16227 PyObject *resultobj;
16228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16229 int arg2 = (int) 0 ;
16230 int arg3 = (int) 0 ;
16231 wxScrollWinEvent *result;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 PyObject * obj2 = 0 ;
16235 char *kwnames[] = {
16236 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16237 };
16238
16239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16240 if (obj0) {
16241 {
16242 arg1 = (wxEventType)(SWIG_As_int(obj0));
16243 if (SWIG_arg_fail(1)) SWIG_fail;
16244 }
16245 }
16246 if (obj1) {
16247 {
16248 arg2 = (int)(SWIG_As_int(obj1));
16249 if (SWIG_arg_fail(2)) SWIG_fail;
16250 }
16251 }
16252 if (obj2) {
16253 {
16254 arg3 = (int)(SWIG_As_int(obj2));
16255 if (SWIG_arg_fail(3)) SWIG_fail;
16256 }
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16261
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj;
16274 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16275 int result;
16276 PyObject * obj0 = 0 ;
16277 char *kwnames[] = {
16278 (char *) "self", NULL
16279 };
16280
16281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16283 if (SWIG_arg_fail(1)) SWIG_fail;
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16287
16288 wxPyEndAllowThreads(__tstate);
16289 if (PyErr_Occurred()) SWIG_fail;
16290 }
16291 {
16292 resultobj = SWIG_From_int((int)(result));
16293 }
16294 return resultobj;
16295 fail:
16296 return NULL;
16297 }
16298
16299
16300 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16301 PyObject *resultobj;
16302 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16303 int result;
16304 PyObject * obj0 = 0 ;
16305 char *kwnames[] = {
16306 (char *) "self", NULL
16307 };
16308
16309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16311 if (SWIG_arg_fail(1)) SWIG_fail;
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16315
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 {
16320 resultobj = SWIG_From_int((int)(result));
16321 }
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16329 PyObject *resultobj;
16330 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16331 int arg2 ;
16332 PyObject * obj0 = 0 ;
16333 PyObject * obj1 = 0 ;
16334 char *kwnames[] = {
16335 (char *) "self",(char *) "orient", NULL
16336 };
16337
16338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16340 if (SWIG_arg_fail(1)) SWIG_fail;
16341 {
16342 arg2 = (int)(SWIG_As_int(obj1));
16343 if (SWIG_arg_fail(2)) SWIG_fail;
16344 }
16345 {
16346 PyThreadState* __tstate = wxPyBeginAllowThreads();
16347 (arg1)->SetOrientation(arg2);
16348
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 Py_INCREF(Py_None); resultobj = Py_None;
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj;
16361 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16362 int arg2 ;
16363 PyObject * obj0 = 0 ;
16364 PyObject * obj1 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self",(char *) "pos", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 arg2 = (int)(SWIG_As_int(obj1));
16374 if (SWIG_arg_fail(2)) SWIG_fail;
16375 }
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 (arg1)->SetPosition(arg2);
16379
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 Py_INCREF(Py_None); resultobj = Py_None;
16384 return resultobj;
16385 fail:
16386 return NULL;
16387 }
16388
16389
16390 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16391 PyObject *obj;
16392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16393 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16394 Py_INCREF(obj);
16395 return Py_BuildValue((char *)"");
16396 }
16397 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16400 wxMouseEvent *result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "mouseType", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16407 if (obj0) {
16408 {
16409 arg1 = (wxEventType)(SWIG_As_int(obj0));
16410 if (SWIG_arg_fail(1)) SWIG_fail;
16411 }
16412 }
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 {
16421 resultobj = wxPyMake_wxObject(result, 1);
16422 }
16423 return resultobj;
16424 fail:
16425 return NULL;
16426 }
16427
16428
16429 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16430 PyObject *resultobj;
16431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16432 bool result;
16433 PyObject * obj0 = 0 ;
16434 char *kwnames[] = {
16435 (char *) "self", NULL
16436 };
16437
16438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16440 if (SWIG_arg_fail(1)) SWIG_fail;
16441 {
16442 PyThreadState* __tstate = wxPyBeginAllowThreads();
16443 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16444
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 {
16449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16450 }
16451 return resultobj;
16452 fail:
16453 return NULL;
16454 }
16455
16456
16457 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16458 PyObject *resultobj;
16459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16460 int arg2 = (int) wxMOUSE_BTN_ANY ;
16461 bool result;
16462 PyObject * obj0 = 0 ;
16463 PyObject * obj1 = 0 ;
16464 char *kwnames[] = {
16465 (char *) "self",(char *) "but", NULL
16466 };
16467
16468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16470 if (SWIG_arg_fail(1)) SWIG_fail;
16471 if (obj1) {
16472 {
16473 arg2 = (int)(SWIG_As_int(obj1));
16474 if (SWIG_arg_fail(2)) SWIG_fail;
16475 }
16476 }
16477 {
16478 PyThreadState* __tstate = wxPyBeginAllowThreads();
16479 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16480
16481 wxPyEndAllowThreads(__tstate);
16482 if (PyErr_Occurred()) SWIG_fail;
16483 }
16484 {
16485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16486 }
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16494 PyObject *resultobj;
16495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16496 int arg2 = (int) wxMOUSE_BTN_ANY ;
16497 bool result;
16498 PyObject * obj0 = 0 ;
16499 PyObject * obj1 = 0 ;
16500 char *kwnames[] = {
16501 (char *) "self",(char *) "but", NULL
16502 };
16503
16504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16506 if (SWIG_arg_fail(1)) SWIG_fail;
16507 if (obj1) {
16508 {
16509 arg2 = (int)(SWIG_As_int(obj1));
16510 if (SWIG_arg_fail(2)) SWIG_fail;
16511 }
16512 }
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16516
16517 wxPyEndAllowThreads(__tstate);
16518 if (PyErr_Occurred()) SWIG_fail;
16519 }
16520 {
16521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16522 }
16523 return resultobj;
16524 fail:
16525 return NULL;
16526 }
16527
16528
16529 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16530 PyObject *resultobj;
16531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16532 int arg2 = (int) wxMOUSE_BTN_ANY ;
16533 bool result;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self",(char *) "but", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 if (obj1) {
16544 {
16545 arg2 = (int)(SWIG_As_int(obj1));
16546 if (SWIG_arg_fail(2)) SWIG_fail;
16547 }
16548 }
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16558 }
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj;
16567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16568 int arg2 ;
16569 bool result;
16570 PyObject * obj0 = 0 ;
16571 PyObject * obj1 = 0 ;
16572 char *kwnames[] = {
16573 (char *) "self",(char *) "button", NULL
16574 };
16575
16576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16578 if (SWIG_arg_fail(1)) SWIG_fail;
16579 {
16580 arg2 = (int)(SWIG_As_int(obj1));
16581 if (SWIG_arg_fail(2)) SWIG_fail;
16582 }
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16586
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 {
16591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16592 }
16593 return resultobj;
16594 fail:
16595 return NULL;
16596 }
16597
16598
16599 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16600 PyObject *resultobj;
16601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16602 int arg2 ;
16603 bool result;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "self",(char *) "but", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16612 if (SWIG_arg_fail(1)) SWIG_fail;
16613 {
16614 arg2 = (int)(SWIG_As_int(obj1));
16615 if (SWIG_arg_fail(2)) SWIG_fail;
16616 }
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16620
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 {
16625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16626 }
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj;
16635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16636 int result;
16637 PyObject * obj0 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16648
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = SWIG_From_int((int)(result));
16654 }
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj;
16663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16664 bool result;
16665 PyObject * obj0 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "self", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16672 if (SWIG_arg_fail(1)) SWIG_fail;
16673 {
16674 PyThreadState* __tstate = wxPyBeginAllowThreads();
16675 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16676
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16682 }
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj;
16691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16692 bool result;
16693 PyObject * obj0 = 0 ;
16694 char *kwnames[] = {
16695 (char *) "self", NULL
16696 };
16697
16698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16700 if (SWIG_arg_fail(1)) SWIG_fail;
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16704
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 {
16709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16710 }
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16720 bool result;
16721 PyObject * obj0 = 0 ;
16722 char *kwnames[] = {
16723 (char *) "self", NULL
16724 };
16725
16726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16728 if (SWIG_arg_fail(1)) SWIG_fail;
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj;
16747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16748 bool result;
16749 PyObject * obj0 = 0 ;
16750 char *kwnames[] = {
16751 (char *) "self", NULL
16752 };
16753
16754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16756 if (SWIG_arg_fail(1)) SWIG_fail;
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16760
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 {
16765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16766 }
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16776 bool result;
16777 PyObject * obj0 = 0 ;
16778 char *kwnames[] = {
16779 (char *) "self", NULL
16780 };
16781
16782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16784 if (SWIG_arg_fail(1)) SWIG_fail;
16785 {
16786 PyThreadState* __tstate = wxPyBeginAllowThreads();
16787 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16788
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16794 }
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj;
16803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16804 bool result;
16805 PyObject * obj0 = 0 ;
16806 char *kwnames[] = {
16807 (char *) "self", NULL
16808 };
16809
16810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16812 if (SWIG_arg_fail(1)) SWIG_fail;
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16816
16817 wxPyEndAllowThreads(__tstate);
16818 if (PyErr_Occurred()) SWIG_fail;
16819 }
16820 {
16821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16822 }
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16832 bool result;
16833 PyObject * obj0 = 0 ;
16834 char *kwnames[] = {
16835 (char *) "self", NULL
16836 };
16837
16838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16840 if (SWIG_arg_fail(1)) SWIG_fail;
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16844
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 {
16849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16850 }
16851 return resultobj;
16852 fail:
16853 return NULL;
16854 }
16855
16856
16857 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16858 PyObject *resultobj;
16859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16860 bool result;
16861 PyObject * obj0 = 0 ;
16862 char *kwnames[] = {
16863 (char *) "self", NULL
16864 };
16865
16866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16868 if (SWIG_arg_fail(1)) SWIG_fail;
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16872
16873 wxPyEndAllowThreads(__tstate);
16874 if (PyErr_Occurred()) SWIG_fail;
16875 }
16876 {
16877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16878 }
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16888 bool result;
16889 PyObject * obj0 = 0 ;
16890 char *kwnames[] = {
16891 (char *) "self", NULL
16892 };
16893
16894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16896 if (SWIG_arg_fail(1)) SWIG_fail;
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16900
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 {
16905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16906 }
16907 return resultobj;
16908 fail:
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16916 bool result;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16928
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 {
16933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16934 }
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj;
16943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16944 bool result;
16945 PyObject * obj0 = 0 ;
16946 char *kwnames[] = {
16947 (char *) "self", NULL
16948 };
16949
16950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16952 if (SWIG_arg_fail(1)) SWIG_fail;
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16956
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 {
16961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16962 }
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj;
16971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16972 bool result;
16973 PyObject * obj0 = 0 ;
16974 char *kwnames[] = {
16975 (char *) "self", NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16980 if (SWIG_arg_fail(1)) SWIG_fail;
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16984
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 {
16989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16990 }
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16998 PyObject *resultobj;
16999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17000 bool result;
17001 PyObject * obj0 = 0 ;
17002 char *kwnames[] = {
17003 (char *) "self", NULL
17004 };
17005
17006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17008 if (SWIG_arg_fail(1)) SWIG_fail;
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17012
17013 wxPyEndAllowThreads(__tstate);
17014 if (PyErr_Occurred()) SWIG_fail;
17015 }
17016 {
17017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17018 }
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17026 PyObject *resultobj;
17027 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17028 bool result;
17029 PyObject * obj0 = 0 ;
17030 char *kwnames[] = {
17031 (char *) "self", NULL
17032 };
17033
17034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17036 if (SWIG_arg_fail(1)) SWIG_fail;
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17040
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 {
17045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17046 }
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj;
17055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17056 bool result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (bool)(arg1)->LeftIsDown();
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 bool result;
17085 PyObject * obj0 = 0 ;
17086 char *kwnames[] = {
17087 (char *) "self", NULL
17088 };
17089
17090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17092 if (SWIG_arg_fail(1)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (bool)(arg1)->MiddleIsDown();
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 {
17101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj;
17111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17112 bool result;
17113 PyObject * obj0 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)(arg1)->RightIsDown();
17124
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 {
17129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17130 }
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj;
17139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17140 bool result;
17141 PyObject * obj0 = 0 ;
17142 char *kwnames[] = {
17143 (char *) "self", NULL
17144 };
17145
17146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17148 if (SWIG_arg_fail(1)) SWIG_fail;
17149 {
17150 PyThreadState* __tstate = wxPyBeginAllowThreads();
17151 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17152
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 {
17157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17158 }
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj;
17167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17168 bool result;
17169 PyObject * obj0 = 0 ;
17170 char *kwnames[] = {
17171 (char *) "self", NULL
17172 };
17173
17174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17176 if (SWIG_arg_fail(1)) SWIG_fail;
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17180
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 {
17185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17186 }
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj;
17195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17196 bool result;
17197 PyObject * obj0 = 0 ;
17198 char *kwnames[] = {
17199 (char *) "self", NULL
17200 };
17201
17202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17204 if (SWIG_arg_fail(1)) SWIG_fail;
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17208
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 {
17213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17214 }
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 bool result;
17225 PyObject * obj0 = 0 ;
17226 char *kwnames[] = {
17227 (char *) "self", NULL
17228 };
17229
17230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17232 if (SWIG_arg_fail(1)) SWIG_fail;
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17236
17237 wxPyEndAllowThreads(__tstate);
17238 if (PyErr_Occurred()) SWIG_fail;
17239 }
17240 {
17241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17242 }
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj;
17251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17252 wxPoint result;
17253 PyObject * obj0 = 0 ;
17254 char *kwnames[] = {
17255 (char *) "self", NULL
17256 };
17257
17258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17260 if (SWIG_arg_fail(1)) SWIG_fail;
17261 {
17262 PyThreadState* __tstate = wxPyBeginAllowThreads();
17263 result = (arg1)->GetPosition();
17264
17265 wxPyEndAllowThreads(__tstate);
17266 if (PyErr_Occurred()) SWIG_fail;
17267 }
17268 {
17269 wxPoint * resultptr;
17270 resultptr = new wxPoint((wxPoint &)(result));
17271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17272 }
17273 return resultobj;
17274 fail:
17275 return NULL;
17276 }
17277
17278
17279 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17280 PyObject *resultobj;
17281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17282 long *arg2 = (long *) 0 ;
17283 long *arg3 = (long *) 0 ;
17284 long temp2 ;
17285 int res2 = 0 ;
17286 long temp3 ;
17287 int res3 = 0 ;
17288 PyObject * obj0 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self", NULL
17291 };
17292
17293 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17294 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17297 if (SWIG_arg_fail(1)) SWIG_fail;
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 (arg1)->GetPosition(arg2,arg3);
17301
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 Py_INCREF(Py_None); resultobj = Py_None;
17306 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17307 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17308 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17309 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17310 return resultobj;
17311 fail:
17312 return NULL;
17313 }
17314
17315
17316 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17317 PyObject *resultobj;
17318 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17319 wxDC *arg2 = 0 ;
17320 wxPoint result;
17321 PyObject * obj0 = 0 ;
17322 PyObject * obj1 = 0 ;
17323 char *kwnames[] = {
17324 (char *) "self",(char *) "dc", NULL
17325 };
17326
17327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17329 if (SWIG_arg_fail(1)) SWIG_fail;
17330 {
17331 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17332 if (SWIG_arg_fail(2)) SWIG_fail;
17333 if (arg2 == NULL) {
17334 SWIG_null_ref("wxDC");
17335 }
17336 if (SWIG_arg_fail(2)) SWIG_fail;
17337 }
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17341
17342 wxPyEndAllowThreads(__tstate);
17343 if (PyErr_Occurred()) SWIG_fail;
17344 }
17345 {
17346 wxPoint * resultptr;
17347 resultptr = new wxPoint((wxPoint &)(result));
17348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 int result;
17360 PyObject * obj0 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (int)((wxMouseEvent const *)arg1)->GetX();
17371
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = SWIG_From_int((int)(result));
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17387 int result;
17388 PyObject * obj0 = 0 ;
17389 char *kwnames[] = {
17390 (char *) "self", NULL
17391 };
17392
17393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17395 if (SWIG_arg_fail(1)) SWIG_fail;
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (int)((wxMouseEvent const *)arg1)->GetY();
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 {
17404 resultobj = SWIG_From_int((int)(result));
17405 }
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj;
17414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17415 int result;
17416 PyObject * obj0 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17423 if (SWIG_arg_fail(1)) SWIG_fail;
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = SWIG_From_int((int)(result));
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17443 int result;
17444 PyObject * obj0 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17455
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 {
17460 resultobj = SWIG_From_int((int)(result));
17461 }
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj;
17470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17471 int result;
17472 PyObject * obj0 = 0 ;
17473 char *kwnames[] = {
17474 (char *) "self", NULL
17475 };
17476
17477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17479 if (SWIG_arg_fail(1)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = SWIG_From_int((int)(result));
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj;
17498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17499 bool result;
17500 PyObject * obj0 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "self", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17507 if (SWIG_arg_fail(1)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17511
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 {
17516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 int arg2 ;
17528 PyObject * obj0 = 0 ;
17529 PyObject * obj1 = 0 ;
17530 char *kwnames[] = {
17531 (char *) "self",(char *) "m_x", NULL
17532 };
17533
17534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17536 if (SWIG_arg_fail(1)) SWIG_fail;
17537 {
17538 arg2 = (int)(SWIG_As_int(obj1));
17539 if (SWIG_arg_fail(2)) SWIG_fail;
17540 }
17541 if (arg1) (arg1)->m_x = arg2;
17542
17543 Py_INCREF(Py_None); resultobj = Py_None;
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj;
17552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17553 int result;
17554 PyObject * obj0 = 0 ;
17555 char *kwnames[] = {
17556 (char *) "self", NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17561 if (SWIG_arg_fail(1)) SWIG_fail;
17562 result = (int) ((arg1)->m_x);
17563
17564 {
17565 resultobj = SWIG_From_int((int)(result));
17566 }
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj;
17575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17576 int arg2 ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "m_y", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = (int)(SWIG_As_int(obj1));
17588 if (SWIG_arg_fail(2)) SWIG_fail;
17589 }
17590 if (arg1) (arg1)->m_y = arg2;
17591
17592 Py_INCREF(Py_None); resultobj = Py_None;
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj;
17601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17602 int result;
17603 PyObject * obj0 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 result = (int) ((arg1)->m_y);
17612
17613 {
17614 resultobj = SWIG_From_int((int)(result));
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj;
17624 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17625 bool arg2 ;
17626 PyObject * obj0 = 0 ;
17627 PyObject * obj1 = 0 ;
17628 char *kwnames[] = {
17629 (char *) "self",(char *) "m_leftDown", NULL
17630 };
17631
17632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17634 if (SWIG_arg_fail(1)) SWIG_fail;
17635 {
17636 arg2 = (bool)(SWIG_As_bool(obj1));
17637 if (SWIG_arg_fail(2)) SWIG_fail;
17638 }
17639 if (arg1) (arg1)->m_leftDown = arg2;
17640
17641 Py_INCREF(Py_None); resultobj = Py_None;
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj;
17650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17651 bool result;
17652 PyObject * obj0 = 0 ;
17653 char *kwnames[] = {
17654 (char *) "self", NULL
17655 };
17656
17657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17659 if (SWIG_arg_fail(1)) SWIG_fail;
17660 result = (bool) ((arg1)->m_leftDown);
17661
17662 {
17663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17664 }
17665 return resultobj;
17666 fail:
17667 return NULL;
17668 }
17669
17670
17671 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17672 PyObject *resultobj;
17673 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17674 bool arg2 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "m_middleDown", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = (bool)(SWIG_As_bool(obj1));
17686 if (SWIG_arg_fail(2)) SWIG_fail;
17687 }
17688 if (arg1) (arg1)->m_middleDown = arg2;
17689
17690 Py_INCREF(Py_None); resultobj = Py_None;
17691 return resultobj;
17692 fail:
17693 return NULL;
17694 }
17695
17696
17697 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17698 PyObject *resultobj;
17699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17700 bool result;
17701 PyObject * obj0 = 0 ;
17702 char *kwnames[] = {
17703 (char *) "self", NULL
17704 };
17705
17706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17708 if (SWIG_arg_fail(1)) SWIG_fail;
17709 result = (bool) ((arg1)->m_middleDown);
17710
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool arg2 ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char *kwnames[] = {
17727 (char *) "self",(char *) "m_rightDown", NULL
17728 };
17729
17730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17732 if (SWIG_arg_fail(1)) SWIG_fail;
17733 {
17734 arg2 = (bool)(SWIG_As_bool(obj1));
17735 if (SWIG_arg_fail(2)) SWIG_fail;
17736 }
17737 if (arg1) (arg1)->m_rightDown = arg2;
17738
17739 Py_INCREF(Py_None); resultobj = Py_None;
17740 return resultobj;
17741 fail:
17742 return NULL;
17743 }
17744
17745
17746 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj;
17748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17749 bool result;
17750 PyObject * obj0 = 0 ;
17751 char *kwnames[] = {
17752 (char *) "self", NULL
17753 };
17754
17755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17757 if (SWIG_arg_fail(1)) SWIG_fail;
17758 result = (bool) ((arg1)->m_rightDown);
17759
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 return resultobj;
17764 fail:
17765 return NULL;
17766 }
17767
17768
17769 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17770 PyObject *resultobj;
17771 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17772 bool arg2 ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char *kwnames[] = {
17776 (char *) "self",(char *) "m_controlDown", NULL
17777 };
17778
17779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17781 if (SWIG_arg_fail(1)) SWIG_fail;
17782 {
17783 arg2 = (bool)(SWIG_As_bool(obj1));
17784 if (SWIG_arg_fail(2)) SWIG_fail;
17785 }
17786 if (arg1) (arg1)->m_controlDown = arg2;
17787
17788 Py_INCREF(Py_None); resultobj = Py_None;
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 bool result;
17799 PyObject * obj0 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "self", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17806 if (SWIG_arg_fail(1)) SWIG_fail;
17807 result = (bool) ((arg1)->m_controlDown);
17808
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17821 bool arg2 ;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "m_shiftDown", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 {
17832 arg2 = (bool)(SWIG_As_bool(obj1));
17833 if (SWIG_arg_fail(2)) SWIG_fail;
17834 }
17835 if (arg1) (arg1)->m_shiftDown = arg2;
17836
17837 Py_INCREF(Py_None); resultobj = Py_None;
17838 return resultobj;
17839 fail:
17840 return NULL;
17841 }
17842
17843
17844 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17845 PyObject *resultobj;
17846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17847 bool result;
17848 PyObject * obj0 = 0 ;
17849 char *kwnames[] = {
17850 (char *) "self", NULL
17851 };
17852
17853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17855 if (SWIG_arg_fail(1)) SWIG_fail;
17856 result = (bool) ((arg1)->m_shiftDown);
17857
17858 {
17859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17868 PyObject *resultobj;
17869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17870 bool arg2 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char *kwnames[] = {
17874 (char *) "self",(char *) "m_altDown", NULL
17875 };
17876
17877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17879 if (SWIG_arg_fail(1)) SWIG_fail;
17880 {
17881 arg2 = (bool)(SWIG_As_bool(obj1));
17882 if (SWIG_arg_fail(2)) SWIG_fail;
17883 }
17884 if (arg1) (arg1)->m_altDown = arg2;
17885
17886 Py_INCREF(Py_None); resultobj = Py_None;
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17896 bool result;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 result = (bool) ((arg1)->m_altDown);
17906
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj;
17918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17919 bool arg2 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char *kwnames[] = {
17923 (char *) "self",(char *) "m_metaDown", NULL
17924 };
17925
17926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17928 if (SWIG_arg_fail(1)) SWIG_fail;
17929 {
17930 arg2 = (bool)(SWIG_As_bool(obj1));
17931 if (SWIG_arg_fail(2)) SWIG_fail;
17932 }
17933 if (arg1) (arg1)->m_metaDown = arg2;
17934
17935 Py_INCREF(Py_None); resultobj = Py_None;
17936 return resultobj;
17937 fail:
17938 return NULL;
17939 }
17940
17941
17942 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17943 PyObject *resultobj;
17944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17945 bool result;
17946 PyObject * obj0 = 0 ;
17947 char *kwnames[] = {
17948 (char *) "self", NULL
17949 };
17950
17951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(1)) SWIG_fail;
17954 result = (bool) ((arg1)->m_metaDown);
17955
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17968 int arg2 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 char *kwnames[] = {
17972 (char *) "self",(char *) "m_wheelRotation", NULL
17973 };
17974
17975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17977 if (SWIG_arg_fail(1)) SWIG_fail;
17978 {
17979 arg2 = (int)(SWIG_As_int(obj1));
17980 if (SWIG_arg_fail(2)) SWIG_fail;
17981 }
17982 if (arg1) (arg1)->m_wheelRotation = arg2;
17983
17984 Py_INCREF(Py_None); resultobj = Py_None;
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17992 PyObject *resultobj;
17993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17994 int result;
17995 PyObject * obj0 = 0 ;
17996 char *kwnames[] = {
17997 (char *) "self", NULL
17998 };
17999
18000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18002 if (SWIG_arg_fail(1)) SWIG_fail;
18003 result = (int) ((arg1)->m_wheelRotation);
18004
18005 {
18006 resultobj = SWIG_From_int((int)(result));
18007 }
18008 return resultobj;
18009 fail:
18010 return NULL;
18011 }
18012
18013
18014 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18015 PyObject *resultobj;
18016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18017 int arg2 ;
18018 PyObject * obj0 = 0 ;
18019 PyObject * obj1 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self",(char *) "m_wheelDelta", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 arg2 = (int)(SWIG_As_int(obj1));
18029 if (SWIG_arg_fail(2)) SWIG_fail;
18030 }
18031 if (arg1) (arg1)->m_wheelDelta = arg2;
18032
18033 Py_INCREF(Py_None); resultobj = Py_None;
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18043 int result;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "self", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 result = (int) ((arg1)->m_wheelDelta);
18053
18054 {
18055 resultobj = SWIG_From_int((int)(result));
18056 }
18057 return resultobj;
18058 fail:
18059 return NULL;
18060 }
18061
18062
18063 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18064 PyObject *resultobj;
18065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18066 int arg2 ;
18067 PyObject * obj0 = 0 ;
18068 PyObject * obj1 = 0 ;
18069 char *kwnames[] = {
18070 (char *) "self",(char *) "m_linesPerAction", NULL
18071 };
18072
18073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18075 if (SWIG_arg_fail(1)) SWIG_fail;
18076 {
18077 arg2 = (int)(SWIG_As_int(obj1));
18078 if (SWIG_arg_fail(2)) SWIG_fail;
18079 }
18080 if (arg1) (arg1)->m_linesPerAction = arg2;
18081
18082 Py_INCREF(Py_None); resultobj = Py_None;
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18092 int result;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 result = (int) ((arg1)->m_linesPerAction);
18102
18103 {
18104 resultobj = SWIG_From_int((int)(result));
18105 }
18106 return resultobj;
18107 fail:
18108 return NULL;
18109 }
18110
18111
18112 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18113 PyObject *obj;
18114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18115 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18116 Py_INCREF(obj);
18117 return Py_BuildValue((char *)"");
18118 }
18119 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj;
18121 int arg1 = (int) 0 ;
18122 int arg2 = (int) 0 ;
18123 wxSetCursorEvent *result;
18124 PyObject * obj0 = 0 ;
18125 PyObject * obj1 = 0 ;
18126 char *kwnames[] = {
18127 (char *) "x",(char *) "y", NULL
18128 };
18129
18130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18131 if (obj0) {
18132 {
18133 arg1 = (int)(SWIG_As_int(obj0));
18134 if (SWIG_arg_fail(1)) SWIG_fail;
18135 }
18136 }
18137 if (obj1) {
18138 {
18139 arg2 = (int)(SWIG_As_int(obj1));
18140 if (SWIG_arg_fail(2)) SWIG_fail;
18141 }
18142 }
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18151 return resultobj;
18152 fail:
18153 return NULL;
18154 }
18155
18156
18157 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18158 PyObject *resultobj;
18159 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18160 int result;
18161 PyObject * obj0 = 0 ;
18162 char *kwnames[] = {
18163 (char *) "self", NULL
18164 };
18165
18166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18168 if (SWIG_arg_fail(1)) SWIG_fail;
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18172
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 {
18177 resultobj = SWIG_From_int((int)(result));
18178 }
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18186 PyObject *resultobj;
18187 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18188 int result;
18189 PyObject * obj0 = 0 ;
18190 char *kwnames[] = {
18191 (char *) "self", NULL
18192 };
18193
18194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18196 if (SWIG_arg_fail(1)) SWIG_fail;
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18200
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = SWIG_From_int((int)(result));
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18216 wxCursor *arg2 = 0 ;
18217 PyObject * obj0 = 0 ;
18218 PyObject * obj1 = 0 ;
18219 char *kwnames[] = {
18220 (char *) "self",(char *) "cursor", NULL
18221 };
18222
18223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18225 if (SWIG_arg_fail(1)) SWIG_fail;
18226 {
18227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18228 if (SWIG_arg_fail(2)) SWIG_fail;
18229 if (arg2 == NULL) {
18230 SWIG_null_ref("wxCursor");
18231 }
18232 if (SWIG_arg_fail(2)) SWIG_fail;
18233 }
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 (arg1)->SetCursor((wxCursor const &)*arg2);
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 Py_INCREF(Py_None); resultobj = Py_None;
18242 return resultobj;
18243 fail:
18244 return NULL;
18245 }
18246
18247
18248 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18249 PyObject *resultobj;
18250 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18251 wxCursor *result;
18252 PyObject * obj0 = 0 ;
18253 char *kwnames[] = {
18254 (char *) "self", NULL
18255 };
18256
18257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18259 if (SWIG_arg_fail(1)) SWIG_fail;
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 {
18263 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18264 result = (wxCursor *) &_result_ref;
18265 }
18266
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 {
18271 wxCursor* resultptr = new wxCursor(*result);
18272 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18273 }
18274 return resultobj;
18275 fail:
18276 return NULL;
18277 }
18278
18279
18280 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj;
18282 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18283 bool result;
18284 PyObject * obj0 = 0 ;
18285 char *kwnames[] = {
18286 (char *) "self", NULL
18287 };
18288
18289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18291 if (SWIG_arg_fail(1)) SWIG_fail;
18292 {
18293 PyThreadState* __tstate = wxPyBeginAllowThreads();
18294 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18295
18296 wxPyEndAllowThreads(__tstate);
18297 if (PyErr_Occurred()) SWIG_fail;
18298 }
18299 {
18300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18301 }
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18309 PyObject *obj;
18310 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18311 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18312 Py_INCREF(obj);
18313 return Py_BuildValue((char *)"");
18314 }
18315 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18316 PyObject *resultobj;
18317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18318 wxKeyEvent *result;
18319 PyObject * obj0 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "eventType", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18325 if (obj0) {
18326 {
18327 arg1 = (wxEventType)(SWIG_As_int(obj0));
18328 if (SWIG_arg_fail(1)) SWIG_fail;
18329 }
18330 }
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18334
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj;
18347 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18348 bool result;
18349 PyObject * obj0 = 0 ;
18350 char *kwnames[] = {
18351 (char *) "self", NULL
18352 };
18353
18354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18356 if (SWIG_arg_fail(1)) SWIG_fail;
18357 {
18358 PyThreadState* __tstate = wxPyBeginAllowThreads();
18359 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18360
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 {
18365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18366 }
18367 return resultobj;
18368 fail:
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18376 bool result;
18377 PyObject * obj0 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18384 if (SWIG_arg_fail(1)) SWIG_fail;
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18388
18389 wxPyEndAllowThreads(__tstate);
18390 if (PyErr_Occurred()) SWIG_fail;
18391 }
18392 {
18393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18402 PyObject *resultobj;
18403 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18404 bool result;
18405 PyObject * obj0 = 0 ;
18406 char *kwnames[] = {
18407 (char *) "self", NULL
18408 };
18409
18410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18412 if (SWIG_arg_fail(1)) SWIG_fail;
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18416
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 {
18421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18422 }
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 {
18442 PyThreadState* __tstate = wxPyBeginAllowThreads();
18443 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18444
18445 wxPyEndAllowThreads(__tstate);
18446 if (PyErr_Occurred()) SWIG_fail;
18447 }
18448 {
18449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 bool result;
18461 PyObject * obj0 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18472
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj;
18487 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18488 bool result;
18489 PyObject * obj0 = 0 ;
18490 char *kwnames[] = {
18491 (char *) "self", NULL
18492 };
18493
18494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18496 if (SWIG_arg_fail(1)) SWIG_fail;
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18500
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 {
18505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18506 }
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18514 PyObject *resultobj;
18515 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18516 int result;
18517 PyObject * obj0 = 0 ;
18518 char *kwnames[] = {
18519 (char *) "self", NULL
18520 };
18521
18522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18524 if (SWIG_arg_fail(1)) SWIG_fail;
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18528
18529 wxPyEndAllowThreads(__tstate);
18530 if (PyErr_Occurred()) SWIG_fail;
18531 }
18532 {
18533 resultobj = SWIG_From_int((int)(result));
18534 }
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18542 PyObject *resultobj;
18543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18544 int result;
18545 PyObject * obj0 = 0 ;
18546 char *kwnames[] = {
18547 (char *) "self", NULL
18548 };
18549
18550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18552 if (SWIG_arg_fail(1)) SWIG_fail;
18553 {
18554 PyThreadState* __tstate = wxPyBeginAllowThreads();
18555 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18556
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 {
18561 resultobj = SWIG_From_int((int)(result));
18562 }
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj;
18571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18572 unsigned int result;
18573 PyObject * obj0 = 0 ;
18574 char *kwnames[] = {
18575 (char *) "self", NULL
18576 };
18577
18578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18580 if (SWIG_arg_fail(1)) SWIG_fail;
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18584
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 {
18589 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj;
18599 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18600 unsigned int result;
18601 PyObject * obj0 = 0 ;
18602 char *kwnames[] = {
18603 (char *) "self", NULL
18604 };
18605
18606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18608 if (SWIG_arg_fail(1)) SWIG_fail;
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18612
18613 wxPyEndAllowThreads(__tstate);
18614 if (PyErr_Occurred()) SWIG_fail;
18615 }
18616 {
18617 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18618 }
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj;
18627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18628 wxPoint result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (arg1)->GetPosition();
18640
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 {
18645 wxPoint * resultptr;
18646 resultptr = new wxPoint((wxPoint &)(result));
18647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18648 }
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj;
18657 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18658 long *arg2 = (long *) 0 ;
18659 long *arg3 = (long *) 0 ;
18660 long temp2 ;
18661 int res2 = 0 ;
18662 long temp3 ;
18663 int res3 = 0 ;
18664 PyObject * obj0 = 0 ;
18665 char *kwnames[] = {
18666 (char *) "self", NULL
18667 };
18668
18669 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18670 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 {
18675 PyThreadState* __tstate = wxPyBeginAllowThreads();
18676 (arg1)->GetPosition(arg2,arg3);
18677
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 Py_INCREF(Py_None); resultobj = Py_None;
18682 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18683 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18684 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18685 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj;
18694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18695 int result;
18696 PyObject * obj0 = 0 ;
18697 char *kwnames[] = {
18698 (char *) "self", NULL
18699 };
18700
18701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18703 if (SWIG_arg_fail(1)) SWIG_fail;
18704 {
18705 PyThreadState* __tstate = wxPyBeginAllowThreads();
18706 result = (int)((wxKeyEvent const *)arg1)->GetX();
18707
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 {
18712 resultobj = SWIG_From_int((int)(result));
18713 }
18714 return resultobj;
18715 fail:
18716 return NULL;
18717 }
18718
18719
18720 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18721 PyObject *resultobj;
18722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18723 int result;
18724 PyObject * obj0 = 0 ;
18725 char *kwnames[] = {
18726 (char *) "self", NULL
18727 };
18728
18729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18731 if (SWIG_arg_fail(1)) SWIG_fail;
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = (int)((wxKeyEvent const *)arg1)->GetY();
18735
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = SWIG_From_int((int)(result));
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj;
18750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18751 int arg2 ;
18752 PyObject * obj0 = 0 ;
18753 PyObject * obj1 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self",(char *) "m_x", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 arg2 = (int)(SWIG_As_int(obj1));
18763 if (SWIG_arg_fail(2)) SWIG_fail;
18764 }
18765 if (arg1) (arg1)->m_x = arg2;
18766
18767 Py_INCREF(Py_None); resultobj = Py_None;
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18775 PyObject *resultobj;
18776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18777 int result;
18778 PyObject * obj0 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 result = (int) ((arg1)->m_x);
18787
18788 {
18789 resultobj = SWIG_From_int((int)(result));
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj;
18799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18800 int arg2 ;
18801 PyObject * obj0 = 0 ;
18802 PyObject * obj1 = 0 ;
18803 char *kwnames[] = {
18804 (char *) "self",(char *) "m_y", NULL
18805 };
18806
18807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18809 if (SWIG_arg_fail(1)) SWIG_fail;
18810 {
18811 arg2 = (int)(SWIG_As_int(obj1));
18812 if (SWIG_arg_fail(2)) SWIG_fail;
18813 }
18814 if (arg1) (arg1)->m_y = arg2;
18815
18816 Py_INCREF(Py_None); resultobj = Py_None;
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18826 int result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 result = (int) ((arg1)->m_y);
18836
18837 {
18838 resultobj = SWIG_From_int((int)(result));
18839 }
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18849 long arg2 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char *kwnames[] = {
18853 (char *) "self",(char *) "m_keyCode", NULL
18854 };
18855
18856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18858 if (SWIG_arg_fail(1)) SWIG_fail;
18859 {
18860 arg2 = (long)(SWIG_As_long(obj1));
18861 if (SWIG_arg_fail(2)) SWIG_fail;
18862 }
18863 if (arg1) (arg1)->m_keyCode = arg2;
18864
18865 Py_INCREF(Py_None); resultobj = Py_None;
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18875 long result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 result = (long) ((arg1)->m_keyCode);
18885
18886 {
18887 resultobj = SWIG_From_long((long)(result));
18888 }
18889 return resultobj;
18890 fail:
18891 return NULL;
18892 }
18893
18894
18895 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18896 PyObject *resultobj;
18897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18898 bool arg2 ;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "self",(char *) "m_controlDown", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18907 if (SWIG_arg_fail(1)) SWIG_fail;
18908 {
18909 arg2 = (bool)(SWIG_As_bool(obj1));
18910 if (SWIG_arg_fail(2)) SWIG_fail;
18911 }
18912 if (arg1) (arg1)->m_controlDown = arg2;
18913
18914 Py_INCREF(Py_None); resultobj = Py_None;
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj;
18923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18924 bool result;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "self", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18932 if (SWIG_arg_fail(1)) SWIG_fail;
18933 result = (bool) ((arg1)->m_controlDown);
18934
18935 {
18936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18937 }
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18947 bool arg2 ;
18948 PyObject * obj0 = 0 ;
18949 PyObject * obj1 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "self",(char *) "m_shiftDown", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18956 if (SWIG_arg_fail(1)) SWIG_fail;
18957 {
18958 arg2 = (bool)(SWIG_As_bool(obj1));
18959 if (SWIG_arg_fail(2)) SWIG_fail;
18960 }
18961 if (arg1) (arg1)->m_shiftDown = arg2;
18962
18963 Py_INCREF(Py_None); resultobj = Py_None;
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj;
18972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18973 bool result;
18974 PyObject * obj0 = 0 ;
18975 char *kwnames[] = {
18976 (char *) "self", NULL
18977 };
18978
18979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 result = (bool) ((arg1)->m_shiftDown);
18983
18984 {
18985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18986 }
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj;
18995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18996 bool arg2 ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "self",(char *) "m_altDown", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 {
19007 arg2 = (bool)(SWIG_As_bool(obj1));
19008 if (SWIG_arg_fail(2)) SWIG_fail;
19009 }
19010 if (arg1) (arg1)->m_altDown = arg2;
19011
19012 Py_INCREF(Py_None); resultobj = Py_None;
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj;
19021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19022 bool result;
19023 PyObject * obj0 = 0 ;
19024 char *kwnames[] = {
19025 (char *) "self", NULL
19026 };
19027
19028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19030 if (SWIG_arg_fail(1)) SWIG_fail;
19031 result = (bool) ((arg1)->m_altDown);
19032
19033 {
19034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19035 }
19036 return resultobj;
19037 fail:
19038 return NULL;
19039 }
19040
19041
19042 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19043 PyObject *resultobj;
19044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19045 bool arg2 ;
19046 PyObject * obj0 = 0 ;
19047 PyObject * obj1 = 0 ;
19048 char *kwnames[] = {
19049 (char *) "self",(char *) "m_metaDown", NULL
19050 };
19051
19052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 {
19056 arg2 = (bool)(SWIG_As_bool(obj1));
19057 if (SWIG_arg_fail(2)) SWIG_fail;
19058 }
19059 if (arg1) (arg1)->m_metaDown = arg2;
19060
19061 Py_INCREF(Py_None); resultobj = Py_None;
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj;
19070 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19071 bool result;
19072 PyObject * obj0 = 0 ;
19073 char *kwnames[] = {
19074 (char *) "self", NULL
19075 };
19076
19077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19079 if (SWIG_arg_fail(1)) SWIG_fail;
19080 result = (bool) ((arg1)->m_metaDown);
19081
19082 {
19083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19094 bool arg2 ;
19095 PyObject * obj0 = 0 ;
19096 PyObject * obj1 = 0 ;
19097 char *kwnames[] = {
19098 (char *) "self",(char *) "m_scanCode", NULL
19099 };
19100
19101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19103 if (SWIG_arg_fail(1)) SWIG_fail;
19104 {
19105 arg2 = (bool)(SWIG_As_bool(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 if (arg1) (arg1)->m_scanCode = arg2;
19109
19110 Py_INCREF(Py_None); resultobj = Py_None;
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19120 bool result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "self", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19128 if (SWIG_arg_fail(1)) SWIG_fail;
19129 result = (bool) ((arg1)->m_scanCode);
19130
19131 {
19132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19133 }
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj;
19142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19143 unsigned int arg2 ;
19144 PyObject * obj0 = 0 ;
19145 PyObject * obj1 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self",(char *) "m_rawCode", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19155 if (SWIG_arg_fail(2)) SWIG_fail;
19156 }
19157 if (arg1) (arg1)->m_rawCode = arg2;
19158
19159 Py_INCREF(Py_None); resultobj = Py_None;
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj;
19168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19169 unsigned int result;
19170 PyObject * obj0 = 0 ;
19171 char *kwnames[] = {
19172 (char *) "self", NULL
19173 };
19174
19175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19177 if (SWIG_arg_fail(1)) SWIG_fail;
19178 result = (unsigned int) ((arg1)->m_rawCode);
19179
19180 {
19181 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19182 }
19183 return resultobj;
19184 fail:
19185 return NULL;
19186 }
19187
19188
19189 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19190 PyObject *resultobj;
19191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19192 unsigned int arg2 ;
19193 PyObject * obj0 = 0 ;
19194 PyObject * obj1 = 0 ;
19195 char *kwnames[] = {
19196 (char *) "self",(char *) "m_rawFlags", NULL
19197 };
19198
19199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19201 if (SWIG_arg_fail(1)) SWIG_fail;
19202 {
19203 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19204 if (SWIG_arg_fail(2)) SWIG_fail;
19205 }
19206 if (arg1) (arg1)->m_rawFlags = arg2;
19207
19208 Py_INCREF(Py_None); resultobj = Py_None;
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj;
19217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19218 unsigned int result;
19219 PyObject * obj0 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "self", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 result = (unsigned int) ((arg1)->m_rawFlags);
19228
19229 {
19230 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19239 PyObject *obj;
19240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19241 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19242 Py_INCREF(obj);
19243 return Py_BuildValue((char *)"");
19244 }
19245 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19246 PyObject *resultobj;
19247 wxSize const &arg1_defvalue = wxDefaultSize ;
19248 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19249 int arg2 = (int) 0 ;
19250 wxSizeEvent *result;
19251 wxSize temp1 ;
19252 PyObject * obj0 = 0 ;
19253 PyObject * obj1 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "sz",(char *) "winid", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19259 if (obj0) {
19260 {
19261 arg1 = &temp1;
19262 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19263 }
19264 }
19265 if (obj1) {
19266 {
19267 arg2 = (int)(SWIG_As_int(obj1));
19268 if (SWIG_arg_fail(2)) SWIG_fail;
19269 }
19270 }
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19274
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj;
19287 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19288 wxSize result;
19289 PyObject * obj0 = 0 ;
19290 char *kwnames[] = {
19291 (char *) "self", NULL
19292 };
19293
19294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19296 if (SWIG_arg_fail(1)) SWIG_fail;
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 result = ((wxSizeEvent const *)arg1)->GetSize();
19300
19301 wxPyEndAllowThreads(__tstate);
19302 if (PyErr_Occurred()) SWIG_fail;
19303 }
19304 {
19305 wxSize * resultptr;
19306 resultptr = new wxSize((wxSize &)(result));
19307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19308 }
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19316 PyObject *resultobj;
19317 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19318 wxRect result;
19319 PyObject * obj0 = 0 ;
19320 char *kwnames[] = {
19321 (char *) "self", NULL
19322 };
19323
19324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19326 if (SWIG_arg_fail(1)) SWIG_fail;
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 result = ((wxSizeEvent const *)arg1)->GetRect();
19330
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 {
19335 wxRect * resultptr;
19336 resultptr = new wxRect((wxRect &)(result));
19337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19338 }
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj;
19347 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19348 wxRect arg2 ;
19349 PyObject * obj0 = 0 ;
19350 PyObject * obj1 = 0 ;
19351 char *kwnames[] = {
19352 (char *) "self",(char *) "rect", NULL
19353 };
19354
19355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19357 if (SWIG_arg_fail(1)) SWIG_fail;
19358 {
19359 wxRect * argp;
19360 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19361 if (SWIG_arg_fail(2)) SWIG_fail;
19362 if (argp == NULL) {
19363 SWIG_null_ref("wxRect");
19364 }
19365 if (SWIG_arg_fail(2)) SWIG_fail;
19366 arg2 = *argp;
19367 }
19368 {
19369 PyThreadState* __tstate = wxPyBeginAllowThreads();
19370 (arg1)->SetRect(arg2);
19371
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 Py_INCREF(Py_None); resultobj = Py_None;
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj;
19384 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19385 wxSize arg2 ;
19386 PyObject * obj0 = 0 ;
19387 PyObject * obj1 = 0 ;
19388 char *kwnames[] = {
19389 (char *) "self",(char *) "size", NULL
19390 };
19391
19392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19394 if (SWIG_arg_fail(1)) SWIG_fail;
19395 {
19396 wxSize * argp;
19397 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19398 if (SWIG_arg_fail(2)) SWIG_fail;
19399 if (argp == NULL) {
19400 SWIG_null_ref("wxSize");
19401 }
19402 if (SWIG_arg_fail(2)) SWIG_fail;
19403 arg2 = *argp;
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 wxSizeEvent_SetSize(arg1,arg2);
19408
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 Py_INCREF(Py_None); resultobj = Py_None;
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj;
19421 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19422 wxSize *arg2 = (wxSize *) 0 ;
19423 PyObject * obj0 = 0 ;
19424 PyObject * obj1 = 0 ;
19425 char *kwnames[] = {
19426 (char *) "self",(char *) "m_size", NULL
19427 };
19428
19429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19431 if (SWIG_arg_fail(1)) SWIG_fail;
19432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19433 if (SWIG_arg_fail(2)) SWIG_fail;
19434 if (arg1) (arg1)->m_size = *arg2;
19435
19436 Py_INCREF(Py_None); resultobj = Py_None;
19437 return resultobj;
19438 fail:
19439 return NULL;
19440 }
19441
19442
19443 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj;
19445 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19446 wxSize *result;
19447 PyObject * obj0 = 0 ;
19448 char *kwnames[] = {
19449 (char *) "self", NULL
19450 };
19451
19452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 result = (wxSize *)& ((arg1)->m_size);
19456
19457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj;
19466 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19467 wxRect *arg2 = (wxRect *) 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "self",(char *) "m_rect", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(2)) SWIG_fail;
19479 if (arg1) (arg1)->m_rect = *arg2;
19480
19481 Py_INCREF(Py_None); resultobj = Py_None;
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj;
19490 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19491 wxRect *result;
19492 PyObject * obj0 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "self", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19499 if (SWIG_arg_fail(1)) SWIG_fail;
19500 result = (wxRect *)& ((arg1)->m_rect);
19501
19502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19510 PyObject *obj;
19511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19512 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19513 Py_INCREF(obj);
19514 return Py_BuildValue((char *)"");
19515 }
19516 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19517 PyObject *resultobj;
19518 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19519 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19520 int arg2 = (int) 0 ;
19521 wxMoveEvent *result;
19522 wxPoint temp1 ;
19523 PyObject * obj0 = 0 ;
19524 PyObject * obj1 = 0 ;
19525 char *kwnames[] = {
19526 (char *) "pos",(char *) "winid", NULL
19527 };
19528
19529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19530 if (obj0) {
19531 {
19532 arg1 = &temp1;
19533 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19534 }
19535 }
19536 if (obj1) {
19537 {
19538 arg2 = (int)(SWIG_As_int(obj1));
19539 if (SWIG_arg_fail(2)) SWIG_fail;
19540 }
19541 }
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19559 wxPoint result;
19560 PyObject * obj0 = 0 ;
19561 char *kwnames[] = {
19562 (char *) "self", NULL
19563 };
19564
19565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19567 if (SWIG_arg_fail(1)) SWIG_fail;
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = ((wxMoveEvent const *)arg1)->GetPosition();
19571
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 {
19576 wxPoint * resultptr;
19577 resultptr = new wxPoint((wxPoint &)(result));
19578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19579 }
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19589 wxRect result;
19590 PyObject * obj0 = 0 ;
19591 char *kwnames[] = {
19592 (char *) "self", NULL
19593 };
19594
19595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19597 if (SWIG_arg_fail(1)) SWIG_fail;
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = ((wxMoveEvent const *)arg1)->GetRect();
19601
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 {
19606 wxRect * resultptr;
19607 resultptr = new wxRect((wxRect &)(result));
19608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19609 }
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19617 PyObject *resultobj;
19618 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19619 wxRect *arg2 = 0 ;
19620 wxRect temp2 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 char *kwnames[] = {
19624 (char *) "self",(char *) "rect", NULL
19625 };
19626
19627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19629 if (SWIG_arg_fail(1)) SWIG_fail;
19630 {
19631 arg2 = &temp2;
19632 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19633 }
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 (arg1)->SetRect((wxRect const &)*arg2);
19637
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 Py_INCREF(Py_None); resultobj = Py_None;
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj;
19650 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19651 wxPoint *arg2 = 0 ;
19652 wxPoint temp2 ;
19653 PyObject * obj0 = 0 ;
19654 PyObject * obj1 = 0 ;
19655 char *kwnames[] = {
19656 (char *) "self",(char *) "pos", NULL
19657 };
19658
19659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19661 if (SWIG_arg_fail(1)) SWIG_fail;
19662 {
19663 arg2 = &temp2;
19664 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19665 }
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 (arg1)->SetPosition((wxPoint const &)*arg2);
19669
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 Py_INCREF(Py_None); resultobj = Py_None;
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19681 PyObject *obj;
19682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19683 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19684 Py_INCREF(obj);
19685 return Py_BuildValue((char *)"");
19686 }
19687 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19688 PyObject *resultobj;
19689 int arg1 = (int) 0 ;
19690 wxPaintEvent *result;
19691 PyObject * obj0 = 0 ;
19692 char *kwnames[] = {
19693 (char *) "Id", NULL
19694 };
19695
19696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19697 if (obj0) {
19698 {
19699 arg1 = (int)(SWIG_As_int(obj0));
19700 if (SWIG_arg_fail(1)) SWIG_fail;
19701 }
19702 }
19703 {
19704 PyThreadState* __tstate = wxPyBeginAllowThreads();
19705 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19706
19707 wxPyEndAllowThreads(__tstate);
19708 if (PyErr_Occurred()) SWIG_fail;
19709 }
19710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19711 return resultobj;
19712 fail:
19713 return NULL;
19714 }
19715
19716
19717 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19718 PyObject *obj;
19719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19720 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19721 Py_INCREF(obj);
19722 return Py_BuildValue((char *)"");
19723 }
19724 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19725 PyObject *resultobj;
19726 int arg1 = (int) 0 ;
19727 wxNcPaintEvent *result;
19728 PyObject * obj0 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "winid", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19734 if (obj0) {
19735 {
19736 arg1 = (int)(SWIG_As_int(obj0));
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 }
19739 }
19740 {
19741 PyThreadState* __tstate = wxPyBeginAllowThreads();
19742 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19743
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19748 return resultobj;
19749 fail:
19750 return NULL;
19751 }
19752
19753
19754 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19755 PyObject *obj;
19756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19757 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19758 Py_INCREF(obj);
19759 return Py_BuildValue((char *)"");
19760 }
19761 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 int arg1 = (int) 0 ;
19764 wxDC *arg2 = (wxDC *) NULL ;
19765 wxEraseEvent *result;
19766 PyObject * obj0 = 0 ;
19767 PyObject * obj1 = 0 ;
19768 char *kwnames[] = {
19769 (char *) "Id",(char *) "dc", NULL
19770 };
19771
19772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19773 if (obj0) {
19774 {
19775 arg1 = (int)(SWIG_As_int(obj0));
19776 if (SWIG_arg_fail(1)) SWIG_fail;
19777 }
19778 }
19779 if (obj1) {
19780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19781 if (SWIG_arg_fail(2)) SWIG_fail;
19782 }
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19786
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19798 PyObject *resultobj;
19799 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19800 wxDC *result;
19801 PyObject * obj0 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19812
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 {
19817 resultobj = wxPyMake_wxObject(result, 0);
19818 }
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19826 PyObject *obj;
19827 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19828 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19829 Py_INCREF(obj);
19830 return Py_BuildValue((char *)"");
19831 }
19832 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj;
19834 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19835 int arg2 = (int) 0 ;
19836 wxFocusEvent *result;
19837 PyObject * obj0 = 0 ;
19838 PyObject * obj1 = 0 ;
19839 char *kwnames[] = {
19840 (char *) "type",(char *) "winid", NULL
19841 };
19842
19843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19844 if (obj0) {
19845 {
19846 arg1 = (wxEventType)(SWIG_As_int(obj0));
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 }
19849 }
19850 if (obj1) {
19851 {
19852 arg2 = (int)(SWIG_As_int(obj1));
19853 if (SWIG_arg_fail(2)) SWIG_fail;
19854 }
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19859
19860 wxPyEndAllowThreads(__tstate);
19861 if (PyErr_Occurred()) SWIG_fail;
19862 }
19863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj;
19872 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19873 wxWindow *result;
19874 PyObject * obj0 = 0 ;
19875 char *kwnames[] = {
19876 (char *) "self", NULL
19877 };
19878
19879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19881 if (SWIG_arg_fail(1)) SWIG_fail;
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19885
19886 wxPyEndAllowThreads(__tstate);
19887 if (PyErr_Occurred()) SWIG_fail;
19888 }
19889 {
19890 resultobj = wxPyMake_wxObject(result, 0);
19891 }
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19901 wxWindow *arg2 = (wxWindow *) 0 ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 char *kwnames[] = {
19905 (char *) "self",(char *) "win", NULL
19906 };
19907
19908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19912 if (SWIG_arg_fail(2)) SWIG_fail;
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 (arg1)->SetWindow(arg2);
19916
19917 wxPyEndAllowThreads(__tstate);
19918 if (PyErr_Occurred()) SWIG_fail;
19919 }
19920 Py_INCREF(Py_None); resultobj = Py_None;
19921 return resultobj;
19922 fail:
19923 return NULL;
19924 }
19925
19926
19927 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19928 PyObject *obj;
19929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19930 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19931 Py_INCREF(obj);
19932 return Py_BuildValue((char *)"");
19933 }
19934 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj;
19936 wxWindow *arg1 = (wxWindow *) NULL ;
19937 wxChildFocusEvent *result;
19938 PyObject * obj0 = 0 ;
19939 char *kwnames[] = {
19940 (char *) "win", NULL
19941 };
19942
19943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19944 if (obj0) {
19945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19946 if (SWIG_arg_fail(1)) SWIG_fail;
19947 }
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19956 return resultobj;
19957 fail:
19958 return NULL;
19959 }
19960
19961
19962 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19963 PyObject *resultobj;
19964 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19965 wxWindow *result;
19966 PyObject * obj0 = 0 ;
19967 char *kwnames[] = {
19968 (char *) "self", NULL
19969 };
19970
19971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19973 if (SWIG_arg_fail(1)) SWIG_fail;
19974 {
19975 PyThreadState* __tstate = wxPyBeginAllowThreads();
19976 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19977
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 {
19982 resultobj = wxPyMake_wxObject(result, 0);
19983 }
19984 return resultobj;
19985 fail:
19986 return NULL;
19987 }
19988
19989
19990 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19991 PyObject *obj;
19992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19993 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19994 Py_INCREF(obj);
19995 return Py_BuildValue((char *)"");
19996 }
19997 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj;
19999 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20000 bool arg2 = (bool) true ;
20001 int arg3 = (int) 0 ;
20002 wxActivateEvent *result;
20003 PyObject * obj0 = 0 ;
20004 PyObject * obj1 = 0 ;
20005 PyObject * obj2 = 0 ;
20006 char *kwnames[] = {
20007 (char *) "type",(char *) "active",(char *) "Id", NULL
20008 };
20009
20010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20011 if (obj0) {
20012 {
20013 arg1 = (wxEventType)(SWIG_As_int(obj0));
20014 if (SWIG_arg_fail(1)) SWIG_fail;
20015 }
20016 }
20017 if (obj1) {
20018 {
20019 arg2 = (bool)(SWIG_As_bool(obj1));
20020 if (SWIG_arg_fail(2)) SWIG_fail;
20021 }
20022 }
20023 if (obj2) {
20024 {
20025 arg3 = (int)(SWIG_As_int(obj2));
20026 if (SWIG_arg_fail(3)) SWIG_fail;
20027 }
20028 }
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20032
20033 wxPyEndAllowThreads(__tstate);
20034 if (PyErr_Occurred()) SWIG_fail;
20035 }
20036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20037 return resultobj;
20038 fail:
20039 return NULL;
20040 }
20041
20042
20043 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20044 PyObject *resultobj;
20045 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20046 bool result;
20047 PyObject * obj0 = 0 ;
20048 char *kwnames[] = {
20049 (char *) "self", NULL
20050 };
20051
20052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(1)) SWIG_fail;
20055 {
20056 PyThreadState* __tstate = wxPyBeginAllowThreads();
20057 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20058
20059 wxPyEndAllowThreads(__tstate);
20060 if (PyErr_Occurred()) SWIG_fail;
20061 }
20062 {
20063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20064 }
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20072 PyObject *obj;
20073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20074 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20075 Py_INCREF(obj);
20076 return Py_BuildValue((char *)"");
20077 }
20078 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20079 PyObject *resultobj;
20080 int arg1 = (int) 0 ;
20081 wxInitDialogEvent *result;
20082 PyObject * obj0 = 0 ;
20083 char *kwnames[] = {
20084 (char *) "Id", NULL
20085 };
20086
20087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20088 if (obj0) {
20089 {
20090 arg1 = (int)(SWIG_As_int(obj0));
20091 if (SWIG_arg_fail(1)) SWIG_fail;
20092 }
20093 }
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20097
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20109 PyObject *obj;
20110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20111 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20112 Py_INCREF(obj);
20113 return Py_BuildValue((char *)"");
20114 }
20115 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj;
20117 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20118 int arg2 = (int) 0 ;
20119 wxMenu *arg3 = (wxMenu *) NULL ;
20120 wxMenuEvent *result;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 PyObject * obj2 = 0 ;
20124 char *kwnames[] = {
20125 (char *) "type",(char *) "winid",(char *) "menu", NULL
20126 };
20127
20128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20129 if (obj0) {
20130 {
20131 arg1 = (wxEventType)(SWIG_As_int(obj0));
20132 if (SWIG_arg_fail(1)) SWIG_fail;
20133 }
20134 }
20135 if (obj1) {
20136 {
20137 arg2 = (int)(SWIG_As_int(obj1));
20138 if (SWIG_arg_fail(2)) SWIG_fail;
20139 }
20140 }
20141 if (obj2) {
20142 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(3)) SWIG_fail;
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20148
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20153 return resultobj;
20154 fail:
20155 return NULL;
20156 }
20157
20158
20159 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20160 PyObject *resultobj;
20161 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20162 int result;
20163 PyObject * obj0 = 0 ;
20164 char *kwnames[] = {
20165 (char *) "self", NULL
20166 };
20167
20168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20170 if (SWIG_arg_fail(1)) SWIG_fail;
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20174
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 {
20179 resultobj = SWIG_From_int((int)(result));
20180 }
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20188 PyObject *resultobj;
20189 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20190 bool result;
20191 PyObject * obj0 = 0 ;
20192 char *kwnames[] = {
20193 (char *) "self", NULL
20194 };
20195
20196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20198 if (SWIG_arg_fail(1)) SWIG_fail;
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20202
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 {
20207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20208 }
20209 return resultobj;
20210 fail:
20211 return NULL;
20212 }
20213
20214
20215 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20216 PyObject *resultobj;
20217 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20218 wxMenu *result;
20219 PyObject * obj0 = 0 ;
20220 char *kwnames[] = {
20221 (char *) "self", NULL
20222 };
20223
20224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20226 if (SWIG_arg_fail(1)) SWIG_fail;
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20230
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 {
20235 resultobj = wxPyMake_wxObject(result, 0);
20236 }
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20244 PyObject *obj;
20245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20246 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20247 Py_INCREF(obj);
20248 return Py_BuildValue((char *)"");
20249 }
20250 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj;
20252 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20253 int arg2 = (int) 0 ;
20254 wxCloseEvent *result;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "type",(char *) "winid", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20262 if (obj0) {
20263 {
20264 arg1 = (wxEventType)(SWIG_As_int(obj0));
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 }
20267 }
20268 if (obj1) {
20269 {
20270 arg2 = (int)(SWIG_As_int(obj1));
20271 if (SWIG_arg_fail(2)) SWIG_fail;
20272 }
20273 }
20274 {
20275 PyThreadState* __tstate = wxPyBeginAllowThreads();
20276 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20277
20278 wxPyEndAllowThreads(__tstate);
20279 if (PyErr_Occurred()) SWIG_fail;
20280 }
20281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20289 PyObject *resultobj;
20290 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20291 bool arg2 ;
20292 PyObject * obj0 = 0 ;
20293 PyObject * obj1 = 0 ;
20294 char *kwnames[] = {
20295 (char *) "self",(char *) "logOff", NULL
20296 };
20297
20298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 {
20302 arg2 = (bool)(SWIG_As_bool(obj1));
20303 if (SWIG_arg_fail(2)) SWIG_fail;
20304 }
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 (arg1)->SetLoggingOff(arg2);
20308
20309 wxPyEndAllowThreads(__tstate);
20310 if (PyErr_Occurred()) SWIG_fail;
20311 }
20312 Py_INCREF(Py_None); resultobj = Py_None;
20313 return resultobj;
20314 fail:
20315 return NULL;
20316 }
20317
20318
20319 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20320 PyObject *resultobj;
20321 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20322 bool result;
20323 PyObject * obj0 = 0 ;
20324 char *kwnames[] = {
20325 (char *) "self", NULL
20326 };
20327
20328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20330 if (SWIG_arg_fail(1)) SWIG_fail;
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20334
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 {
20339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20340 }
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20348 PyObject *resultobj;
20349 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20350 bool arg2 = (bool) true ;
20351 PyObject * obj0 = 0 ;
20352 PyObject * obj1 = 0 ;
20353 char *kwnames[] = {
20354 (char *) "self",(char *) "veto", NULL
20355 };
20356
20357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20359 if (SWIG_arg_fail(1)) SWIG_fail;
20360 if (obj1) {
20361 {
20362 arg2 = (bool)(SWIG_As_bool(obj1));
20363 if (SWIG_arg_fail(2)) SWIG_fail;
20364 }
20365 }
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 (arg1)->Veto(arg2);
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 Py_INCREF(Py_None); resultobj = Py_None;
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20381 PyObject *resultobj;
20382 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20383 bool result;
20384 PyObject * obj0 = 0 ;
20385 char *kwnames[] = {
20386 (char *) "self", NULL
20387 };
20388
20389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20391 if (SWIG_arg_fail(1)) SWIG_fail;
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20395
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 {
20400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20401 }
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj;
20410 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20411 bool arg2 ;
20412 PyObject * obj0 = 0 ;
20413 PyObject * obj1 = 0 ;
20414 char *kwnames[] = {
20415 (char *) "self",(char *) "canVeto", NULL
20416 };
20417
20418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20420 if (SWIG_arg_fail(1)) SWIG_fail;
20421 {
20422 arg2 = (bool)(SWIG_As_bool(obj1));
20423 if (SWIG_arg_fail(2)) SWIG_fail;
20424 }
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 (arg1)->SetCanVeto(arg2);
20428
20429 wxPyEndAllowThreads(__tstate);
20430 if (PyErr_Occurred()) SWIG_fail;
20431 }
20432 Py_INCREF(Py_None); resultobj = Py_None;
20433 return resultobj;
20434 fail:
20435 return NULL;
20436 }
20437
20438
20439 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20440 PyObject *resultobj;
20441 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20442 bool result;
20443 PyObject * obj0 = 0 ;
20444 char *kwnames[] = {
20445 (char *) "self", NULL
20446 };
20447
20448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 {
20452 PyThreadState* __tstate = wxPyBeginAllowThreads();
20453 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20454
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 {
20459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20460 }
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20468 PyObject *obj;
20469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20470 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20471 Py_INCREF(obj);
20472 return Py_BuildValue((char *)"");
20473 }
20474 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 int arg1 = (int) 0 ;
20477 bool arg2 = (bool) false ;
20478 wxShowEvent *result;
20479 PyObject * obj0 = 0 ;
20480 PyObject * obj1 = 0 ;
20481 char *kwnames[] = {
20482 (char *) "winid",(char *) "show", NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20486 if (obj0) {
20487 {
20488 arg1 = (int)(SWIG_As_int(obj0));
20489 if (SWIG_arg_fail(1)) SWIG_fail;
20490 }
20491 }
20492 if (obj1) {
20493 {
20494 arg2 = (bool)(SWIG_As_bool(obj1));
20495 if (SWIG_arg_fail(2)) SWIG_fail;
20496 }
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20501
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20513 PyObject *resultobj;
20514 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20515 bool arg2 ;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 char *kwnames[] = {
20519 (char *) "self",(char *) "show", NULL
20520 };
20521
20522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20524 if (SWIG_arg_fail(1)) SWIG_fail;
20525 {
20526 arg2 = (bool)(SWIG_As_bool(obj1));
20527 if (SWIG_arg_fail(2)) SWIG_fail;
20528 }
20529 {
20530 PyThreadState* __tstate = wxPyBeginAllowThreads();
20531 (arg1)->SetShow(arg2);
20532
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 Py_INCREF(Py_None); resultobj = Py_None;
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20544 PyObject *resultobj;
20545 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20546 bool result;
20547 PyObject * obj0 = 0 ;
20548 char *kwnames[] = {
20549 (char *) "self", NULL
20550 };
20551
20552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20554 if (SWIG_arg_fail(1)) SWIG_fail;
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20558
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20564 }
20565 return resultobj;
20566 fail:
20567 return NULL;
20568 }
20569
20570
20571 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20572 PyObject *obj;
20573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20574 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20575 Py_INCREF(obj);
20576 return Py_BuildValue((char *)"");
20577 }
20578 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj;
20580 int arg1 = (int) 0 ;
20581 bool arg2 = (bool) true ;
20582 wxIconizeEvent *result;
20583 PyObject * obj0 = 0 ;
20584 PyObject * obj1 = 0 ;
20585 char *kwnames[] = {
20586 (char *) "id",(char *) "iconized", NULL
20587 };
20588
20589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20590 if (obj0) {
20591 {
20592 arg1 = (int)(SWIG_As_int(obj0));
20593 if (SWIG_arg_fail(1)) SWIG_fail;
20594 }
20595 }
20596 if (obj1) {
20597 {
20598 arg2 = (bool)(SWIG_As_bool(obj1));
20599 if (SWIG_arg_fail(2)) SWIG_fail;
20600 }
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj;
20618 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20619 bool result;
20620 PyObject * obj0 = 0 ;
20621 char *kwnames[] = {
20622 (char *) "self", NULL
20623 };
20624
20625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20627 if (SWIG_arg_fail(1)) SWIG_fail;
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (bool)(arg1)->Iconized();
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20645 PyObject *obj;
20646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20647 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20648 Py_INCREF(obj);
20649 return Py_BuildValue((char *)"");
20650 }
20651 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj;
20653 int arg1 = (int) 0 ;
20654 wxMaximizeEvent *result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "id", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20661 if (obj0) {
20662 {
20663 arg1 = (int)(SWIG_As_int(obj0));
20664 if (SWIG_arg_fail(1)) SWIG_fail;
20665 }
20666 }
20667 {
20668 PyThreadState* __tstate = wxPyBeginAllowThreads();
20669 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20670
20671 wxPyEndAllowThreads(__tstate);
20672 if (PyErr_Occurred()) SWIG_fail;
20673 }
20674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20675 return resultobj;
20676 fail:
20677 return NULL;
20678 }
20679
20680
20681 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20682 PyObject *obj;
20683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20684 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20685 Py_INCREF(obj);
20686 return Py_BuildValue((char *)"");
20687 }
20688 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj;
20690 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20691 wxPoint result;
20692 PyObject * obj0 = 0 ;
20693 char *kwnames[] = {
20694 (char *) "self", NULL
20695 };
20696
20697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (arg1)->GetPosition();
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 wxPoint * resultptr;
20709 resultptr = new wxPoint((wxPoint &)(result));
20710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj;
20720 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20721 int result;
20722 PyObject * obj0 = 0 ;
20723 char *kwnames[] = {
20724 (char *) "self", NULL
20725 };
20726
20727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20729 if (SWIG_arg_fail(1)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (int)(arg1)->GetNumberOfFiles();
20733
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = SWIG_From_int((int)(result));
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj;
20748 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20749 PyObject *result;
20750 PyObject * obj0 = 0 ;
20751 char *kwnames[] = {
20752 (char *) "self", NULL
20753 };
20754
20755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20757 if (SWIG_arg_fail(1)) SWIG_fail;
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20761
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = result;
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20773 PyObject *obj;
20774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20775 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20776 Py_INCREF(obj);
20777 return Py_BuildValue((char *)"");
20778 }
20779 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 int arg1 = (int) 0 ;
20782 wxUpdateUIEvent *result;
20783 PyObject * obj0 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "commandId", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20798
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20812 bool result;
20813 PyObject * obj0 = 0 ;
20814 char *kwnames[] = {
20815 (char *) "self", NULL
20816 };
20817
20818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20820 if (SWIG_arg_fail(1)) SWIG_fail;
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 {
20829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20830 }
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20838 PyObject *resultobj;
20839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20840 bool result;
20841 PyObject * obj0 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "self", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20848 if (SWIG_arg_fail(1)) SWIG_fail;
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20852
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20858 }
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20866 PyObject *resultobj;
20867 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20868 wxString result;
20869 PyObject * obj0 = 0 ;
20870 char *kwnames[] = {
20871 (char *) "self", NULL
20872 };
20873
20874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20876 if (SWIG_arg_fail(1)) SWIG_fail;
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20880
20881 wxPyEndAllowThreads(__tstate);
20882 if (PyErr_Occurred()) SWIG_fail;
20883 }
20884 {
20885 #if wxUSE_UNICODE
20886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20887 #else
20888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20889 #endif
20890 }
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20900 bool result;
20901 PyObject * obj0 = 0 ;
20902 char *kwnames[] = {
20903 (char *) "self", NULL
20904 };
20905
20906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20908 if (SWIG_arg_fail(1)) SWIG_fail;
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20926 PyObject *resultobj;
20927 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20928 bool result;
20929 PyObject * obj0 = 0 ;
20930 char *kwnames[] = {
20931 (char *) "self", NULL
20932 };
20933
20934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20936 if (SWIG_arg_fail(1)) SWIG_fail;
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20940
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 {
20945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20946 }
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20954 PyObject *resultobj;
20955 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20956 bool result;
20957 PyObject * obj0 = 0 ;
20958 char *kwnames[] = {
20959 (char *) "self", NULL
20960 };
20961
20962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20964 if (SWIG_arg_fail(1)) SWIG_fail;
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20968
20969 wxPyEndAllowThreads(__tstate);
20970 if (PyErr_Occurred()) SWIG_fail;
20971 }
20972 {
20973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20974 }
20975 return resultobj;
20976 fail:
20977 return NULL;
20978 }
20979
20980
20981 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20982 PyObject *resultobj;
20983 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20984 bool arg2 ;
20985 PyObject * obj0 = 0 ;
20986 PyObject * obj1 = 0 ;
20987 char *kwnames[] = {
20988 (char *) "self",(char *) "check", NULL
20989 };
20990
20991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20993 if (SWIG_arg_fail(1)) SWIG_fail;
20994 {
20995 arg2 = (bool)(SWIG_As_bool(obj1));
20996 if (SWIG_arg_fail(2)) SWIG_fail;
20997 }
20998 {
20999 PyThreadState* __tstate = wxPyBeginAllowThreads();
21000 (arg1)->Check(arg2);
21001
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 Py_INCREF(Py_None); resultobj = Py_None;
21006 return resultobj;
21007 fail:
21008 return NULL;
21009 }
21010
21011
21012 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21013 PyObject *resultobj;
21014 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21015 bool arg2 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21018 char *kwnames[] = {
21019 (char *) "self",(char *) "enable", NULL
21020 };
21021
21022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21024 if (SWIG_arg_fail(1)) SWIG_fail;
21025 {
21026 arg2 = (bool)(SWIG_As_bool(obj1));
21027 if (SWIG_arg_fail(2)) SWIG_fail;
21028 }
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 (arg1)->Enable(arg2);
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 Py_INCREF(Py_None); resultobj = Py_None;
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj;
21045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21046 wxString *arg2 = 0 ;
21047 bool temp2 = false ;
21048 PyObject * obj0 = 0 ;
21049 PyObject * obj1 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self",(char *) "text", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 arg2 = wxString_in_helper(obj1);
21059 if (arg2 == NULL) SWIG_fail;
21060 temp2 = true;
21061 }
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 (arg1)->SetText((wxString const &)*arg2);
21065
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 Py_INCREF(Py_None); resultobj = Py_None;
21070 {
21071 if (temp2)
21072 delete arg2;
21073 }
21074 return resultobj;
21075 fail:
21076 {
21077 if (temp2)
21078 delete arg2;
21079 }
21080 return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj;
21086 long arg1 ;
21087 PyObject * obj0 = 0 ;
21088 char *kwnames[] = {
21089 (char *) "updateInterval", NULL
21090 };
21091
21092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21093 {
21094 arg1 = (long)(SWIG_As_long(obj0));
21095 if (SWIG_arg_fail(1)) SWIG_fail;
21096 }
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 wxUpdateUIEvent::SetUpdateInterval(arg1);
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 Py_INCREF(Py_None); resultobj = Py_None;
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj;
21113 long result;
21114 char *kwnames[] = {
21115 NULL
21116 };
21117
21118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 {
21127 resultobj = SWIG_From_long((long)(result));
21128 }
21129 return resultobj;
21130 fail:
21131 return NULL;
21132 }
21133
21134
21135 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21136 PyObject *resultobj;
21137 wxWindow *arg1 = (wxWindow *) 0 ;
21138 bool result;
21139 PyObject * obj0 = 0 ;
21140 char *kwnames[] = {
21141 (char *) "win", NULL
21142 };
21143
21144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21146 if (SWIG_arg_fail(1)) SWIG_fail;
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21150
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 {
21155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21156 }
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21164 PyObject *resultobj;
21165 char *kwnames[] = {
21166 NULL
21167 };
21168
21169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 wxUpdateUIEvent::ResetUpdateTime();
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 Py_INCREF(Py_None); resultobj = Py_None;
21178 return resultobj;
21179 fail:
21180 return NULL;
21181 }
21182
21183
21184 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21185 PyObject *resultobj;
21186 wxUpdateUIMode arg1 ;
21187 PyObject * obj0 = 0 ;
21188 char *kwnames[] = {
21189 (char *) "mode", NULL
21190 };
21191
21192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21193 {
21194 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21195 if (SWIG_arg_fail(1)) SWIG_fail;
21196 }
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21200
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 Py_INCREF(Py_None); resultobj = Py_None;
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21212 PyObject *resultobj;
21213 wxUpdateUIMode result;
21214 char *kwnames[] = {
21215 NULL
21216 };
21217
21218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21222
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 resultobj = SWIG_From_int((result));
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21234 PyObject *obj;
21235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21236 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21237 Py_INCREF(obj);
21238 return Py_BuildValue((char *)"");
21239 }
21240 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21241 PyObject *resultobj;
21242 wxSysColourChangedEvent *result;
21243 char *kwnames[] = {
21244 NULL
21245 };
21246
21247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21251
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21263 PyObject *obj;
21264 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21265 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21266 Py_INCREF(obj);
21267 return Py_BuildValue((char *)"");
21268 }
21269 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj;
21271 int arg1 = (int) 0 ;
21272 wxWindow *arg2 = (wxWindow *) NULL ;
21273 wxMouseCaptureChangedEvent *result;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "winid",(char *) "gainedCapture", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21281 if (obj0) {
21282 {
21283 arg1 = (int)(SWIG_As_int(obj0));
21284 if (SWIG_arg_fail(1)) SWIG_fail;
21285 }
21286 }
21287 if (obj1) {
21288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(2)) SWIG_fail;
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21308 wxWindow *result;
21309 PyObject * obj0 = 0 ;
21310 char *kwnames[] = {
21311 (char *) "self", NULL
21312 };
21313
21314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21316 if (SWIG_arg_fail(1)) SWIG_fail;
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21320
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = wxPyMake_wxObject(result, 0);
21326 }
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21334 PyObject *obj;
21335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21336 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21337 Py_INCREF(obj);
21338 return Py_BuildValue((char *)"");
21339 }
21340 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21341 PyObject *resultobj;
21342 wxDisplayChangedEvent *result;
21343 char *kwnames[] = {
21344 NULL
21345 };
21346
21347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21351
21352 wxPyEndAllowThreads(__tstate);
21353 if (PyErr_Occurred()) SWIG_fail;
21354 }
21355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21363 PyObject *obj;
21364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21365 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21366 Py_INCREF(obj);
21367 return Py_BuildValue((char *)"");
21368 }
21369 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj;
21371 int arg1 = (int) 0 ;
21372 wxPaletteChangedEvent *result;
21373 PyObject * obj0 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "id", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21379 if (obj0) {
21380 {
21381 arg1 = (int)(SWIG_As_int(obj0));
21382 if (SWIG_arg_fail(1)) SWIG_fail;
21383 }
21384 }
21385 {
21386 PyThreadState* __tstate = wxPyBeginAllowThreads();
21387 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21388
21389 wxPyEndAllowThreads(__tstate);
21390 if (PyErr_Occurred()) SWIG_fail;
21391 }
21392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21400 PyObject *resultobj;
21401 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21402 wxWindow *arg2 = (wxWindow *) 0 ;
21403 PyObject * obj0 = 0 ;
21404 PyObject * obj1 = 0 ;
21405 char *kwnames[] = {
21406 (char *) "self",(char *) "win", NULL
21407 };
21408
21409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21411 if (SWIG_arg_fail(1)) SWIG_fail;
21412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21413 if (SWIG_arg_fail(2)) SWIG_fail;
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 (arg1)->SetChangedWindow(arg2);
21417
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 Py_INCREF(Py_None); resultobj = Py_None;
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21429 PyObject *resultobj;
21430 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21431 wxWindow *result;
21432 PyObject * obj0 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "self", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 {
21441 PyThreadState* __tstate = wxPyBeginAllowThreads();
21442 result = (wxWindow *)(arg1)->GetChangedWindow();
21443
21444 wxPyEndAllowThreads(__tstate);
21445 if (PyErr_Occurred()) SWIG_fail;
21446 }
21447 {
21448 resultobj = wxPyMake_wxObject(result, 0);
21449 }
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21457 PyObject *obj;
21458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21459 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21460 Py_INCREF(obj);
21461 return Py_BuildValue((char *)"");
21462 }
21463 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21464 PyObject *resultobj;
21465 int arg1 = (int) 0 ;
21466 wxQueryNewPaletteEvent *result;
21467 PyObject * obj0 = 0 ;
21468 char *kwnames[] = {
21469 (char *) "winid", NULL
21470 };
21471
21472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21473 if (obj0) {
21474 {
21475 arg1 = (int)(SWIG_As_int(obj0));
21476 if (SWIG_arg_fail(1)) SWIG_fail;
21477 }
21478 }
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj;
21495 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21496 bool arg2 ;
21497 PyObject * obj0 = 0 ;
21498 PyObject * obj1 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self",(char *) "realized", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 {
21507 arg2 = (bool)(SWIG_As_bool(obj1));
21508 if (SWIG_arg_fail(2)) SWIG_fail;
21509 }
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 (arg1)->SetPaletteRealized(arg2);
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 Py_INCREF(Py_None); resultobj = Py_None;
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21525 PyObject *resultobj;
21526 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21527 bool result;
21528 PyObject * obj0 = 0 ;
21529 char *kwnames[] = {
21530 (char *) "self", NULL
21531 };
21532
21533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21535 if (SWIG_arg_fail(1)) SWIG_fail;
21536 {
21537 PyThreadState* __tstate = wxPyBeginAllowThreads();
21538 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21539
21540 wxPyEndAllowThreads(__tstate);
21541 if (PyErr_Occurred()) SWIG_fail;
21542 }
21543 {
21544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21545 }
21546 return resultobj;
21547 fail:
21548 return NULL;
21549 }
21550
21551
21552 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21553 PyObject *obj;
21554 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21555 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21556 Py_INCREF(obj);
21557 return Py_BuildValue((char *)"");
21558 }
21559 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21560 PyObject *resultobj;
21561 wxNavigationKeyEvent *result;
21562 char *kwnames[] = {
21563 NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21570
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21575 return resultobj;
21576 fail:
21577 return NULL;
21578 }
21579
21580
21581 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21582 PyObject *resultobj;
21583 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21584 bool result;
21585 PyObject * obj0 = 0 ;
21586 char *kwnames[] = {
21587 (char *) "self", NULL
21588 };
21589
21590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21592 if (SWIG_arg_fail(1)) SWIG_fail;
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21596
21597 wxPyEndAllowThreads(__tstate);
21598 if (PyErr_Occurred()) SWIG_fail;
21599 }
21600 {
21601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21602 }
21603 return resultobj;
21604 fail:
21605 return NULL;
21606 }
21607
21608
21609 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21610 PyObject *resultobj;
21611 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21612 bool arg2 ;
21613 PyObject * obj0 = 0 ;
21614 PyObject * obj1 = 0 ;
21615 char *kwnames[] = {
21616 (char *) "self",(char *) "forward", NULL
21617 };
21618
21619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21621 if (SWIG_arg_fail(1)) SWIG_fail;
21622 {
21623 arg2 = (bool)(SWIG_As_bool(obj1));
21624 if (SWIG_arg_fail(2)) SWIG_fail;
21625 }
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 (arg1)->SetDirection(arg2);
21629
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 Py_INCREF(Py_None); resultobj = Py_None;
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21641 PyObject *resultobj;
21642 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21643 bool result;
21644 PyObject * obj0 = 0 ;
21645 char *kwnames[] = {
21646 (char *) "self", NULL
21647 };
21648
21649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21651 if (SWIG_arg_fail(1)) SWIG_fail;
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21655
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 {
21660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21661 }
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj;
21670 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21671 bool arg2 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char *kwnames[] = {
21675 (char *) "self",(char *) "ischange", NULL
21676 };
21677
21678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21680 if (SWIG_arg_fail(1)) SWIG_fail;
21681 {
21682 arg2 = (bool)(SWIG_As_bool(obj1));
21683 if (SWIG_arg_fail(2)) SWIG_fail;
21684 }
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 (arg1)->SetWindowChange(arg2);
21688
21689 wxPyEndAllowThreads(__tstate);
21690 if (PyErr_Occurred()) SWIG_fail;
21691 }
21692 Py_INCREF(Py_None); resultobj = Py_None;
21693 return resultobj;
21694 fail:
21695 return NULL;
21696 }
21697
21698
21699 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21700 PyObject *resultobj;
21701 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21702 bool result;
21703 PyObject * obj0 = 0 ;
21704 char *kwnames[] = {
21705 (char *) "self", NULL
21706 };
21707
21708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21710 if (SWIG_arg_fail(1)) SWIG_fail;
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21714
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 {
21719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21720 }
21721 return resultobj;
21722 fail:
21723 return NULL;
21724 }
21725
21726
21727 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj;
21729 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21730 bool arg2 ;
21731 PyObject * obj0 = 0 ;
21732 PyObject * obj1 = 0 ;
21733 char *kwnames[] = {
21734 (char *) "self",(char *) "bIs", NULL
21735 };
21736
21737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21739 if (SWIG_arg_fail(1)) SWIG_fail;
21740 {
21741 arg2 = (bool)(SWIG_As_bool(obj1));
21742 if (SWIG_arg_fail(2)) SWIG_fail;
21743 }
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 (arg1)->SetFromTab(arg2);
21747
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 Py_INCREF(Py_None); resultobj = Py_None;
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21759 PyObject *resultobj;
21760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21761 long arg2 ;
21762 PyObject * obj0 = 0 ;
21763 PyObject * obj1 = 0 ;
21764 char *kwnames[] = {
21765 (char *) "self",(char *) "flags", NULL
21766 };
21767
21768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21770 if (SWIG_arg_fail(1)) SWIG_fail;
21771 {
21772 arg2 = (long)(SWIG_As_long(obj1));
21773 if (SWIG_arg_fail(2)) SWIG_fail;
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 (arg1)->SetFlags(arg2);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 Py_INCREF(Py_None); resultobj = Py_None;
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21792 wxWindow *result;
21793 PyObject * obj0 = 0 ;
21794 char *kwnames[] = {
21795 (char *) "self", NULL
21796 };
21797
21798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21800 if (SWIG_arg_fail(1)) SWIG_fail;
21801 {
21802 PyThreadState* __tstate = wxPyBeginAllowThreads();
21803 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21804
21805 wxPyEndAllowThreads(__tstate);
21806 if (PyErr_Occurred()) SWIG_fail;
21807 }
21808 {
21809 resultobj = wxPyMake_wxObject(result, 0);
21810 }
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21818 PyObject *resultobj;
21819 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21820 wxWindow *arg2 = (wxWindow *) 0 ;
21821 PyObject * obj0 = 0 ;
21822 PyObject * obj1 = 0 ;
21823 char *kwnames[] = {
21824 (char *) "self",(char *) "win", NULL
21825 };
21826
21827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21829 if (SWIG_arg_fail(1)) SWIG_fail;
21830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21831 if (SWIG_arg_fail(2)) SWIG_fail;
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 (arg1)->SetCurrentFocus(arg2);
21835
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 Py_INCREF(Py_None); resultobj = Py_None;
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21847 PyObject *obj;
21848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21849 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21850 Py_INCREF(obj);
21851 return Py_BuildValue((char *)"");
21852 }
21853 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21854 PyObject *resultobj;
21855 wxWindow *arg1 = (wxWindow *) NULL ;
21856 wxWindowCreateEvent *result;
21857 PyObject * obj0 = 0 ;
21858 char *kwnames[] = {
21859 (char *) "win", NULL
21860 };
21861
21862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21863 if (obj0) {
21864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21865 if (SWIG_arg_fail(1)) SWIG_fail;
21866 }
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21870
21871 wxPyEndAllowThreads(__tstate);
21872 if (PyErr_Occurred()) SWIG_fail;
21873 }
21874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21882 PyObject *resultobj;
21883 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21884 wxWindow *result;
21885 PyObject * obj0 = 0 ;
21886 char *kwnames[] = {
21887 (char *) "self", NULL
21888 };
21889
21890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21892 if (SWIG_arg_fail(1)) SWIG_fail;
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21896
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 {
21901 resultobj = wxPyMake_wxObject(result, 0);
21902 }
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21910 PyObject *obj;
21911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21912 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21913 Py_INCREF(obj);
21914 return Py_BuildValue((char *)"");
21915 }
21916 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj;
21918 wxWindow *arg1 = (wxWindow *) NULL ;
21919 wxWindowDestroyEvent *result;
21920 PyObject * obj0 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "win", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21926 if (obj0) {
21927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21928 if (SWIG_arg_fail(1)) SWIG_fail;
21929 }
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj;
21946 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21947 wxWindow *result;
21948 PyObject * obj0 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21959
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = wxPyMake_wxObject(result, 0);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21973 PyObject *obj;
21974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21975 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21976 Py_INCREF(obj);
21977 return Py_BuildValue((char *)"");
21978 }
21979 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21982 int arg2 = (int) 0 ;
21983 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21984 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21985 wxContextMenuEvent *result;
21986 wxPoint temp3 ;
21987 PyObject * obj0 = 0 ;
21988 PyObject * obj1 = 0 ;
21989 PyObject * obj2 = 0 ;
21990 char *kwnames[] = {
21991 (char *) "type",(char *) "winid",(char *) "pt", NULL
21992 };
21993
21994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21995 if (obj0) {
21996 {
21997 arg1 = (wxEventType)(SWIG_As_int(obj0));
21998 if (SWIG_arg_fail(1)) SWIG_fail;
21999 }
22000 }
22001 if (obj1) {
22002 {
22003 arg2 = (int)(SWIG_As_int(obj1));
22004 if (SWIG_arg_fail(2)) SWIG_fail;
22005 }
22006 }
22007 if (obj2) {
22008 {
22009 arg3 = &temp3;
22010 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22011 }
22012 }
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj;
22029 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22030 wxPoint *result;
22031 PyObject * obj0 = 0 ;
22032 char *kwnames[] = {
22033 (char *) "self", NULL
22034 };
22035
22036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22038 if (SWIG_arg_fail(1)) SWIG_fail;
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 {
22042 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22043 result = (wxPoint *) &_result_ref;
22044 }
22045
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22057 PyObject *resultobj;
22058 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22059 wxPoint *arg2 = 0 ;
22060 wxPoint temp2 ;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 char *kwnames[] = {
22064 (char *) "self",(char *) "pos", NULL
22065 };
22066
22067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(1)) SWIG_fail;
22070 {
22071 arg2 = &temp2;
22072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22073 }
22074 {
22075 PyThreadState* __tstate = wxPyBeginAllowThreads();
22076 (arg1)->SetPosition((wxPoint const &)*arg2);
22077
22078 wxPyEndAllowThreads(__tstate);
22079 if (PyErr_Occurred()) SWIG_fail;
22080 }
22081 Py_INCREF(Py_None); resultobj = Py_None;
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22089 PyObject *obj;
22090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22091 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22092 Py_INCREF(obj);
22093 return Py_BuildValue((char *)"");
22094 }
22095 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22096 PyObject *resultobj;
22097 wxIdleEvent *result;
22098 char *kwnames[] = {
22099 NULL
22100 };
22101
22102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 result = (wxIdleEvent *)new wxIdleEvent();
22106
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22118 PyObject *resultobj;
22119 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22120 bool arg2 = (bool) true ;
22121 PyObject * obj0 = 0 ;
22122 PyObject * obj1 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self",(char *) "needMore", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 if (obj1) {
22131 {
22132 arg2 = (bool)(SWIG_As_bool(obj1));
22133 if (SWIG_arg_fail(2)) SWIG_fail;
22134 }
22135 }
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 (arg1)->RequestMore(arg2);
22139
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 Py_INCREF(Py_None); resultobj = Py_None;
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj;
22152 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22153 bool result;
22154 PyObject * obj0 = 0 ;
22155 char *kwnames[] = {
22156 (char *) "self", NULL
22157 };
22158
22159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(1)) SWIG_fail;
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22165
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj;
22180 wxIdleMode arg1 ;
22181 PyObject * obj0 = 0 ;
22182 char *kwnames[] = {
22183 (char *) "mode", NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22187 {
22188 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22189 if (SWIG_arg_fail(1)) SWIG_fail;
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 wxIdleEvent::SetMode((wxIdleMode )arg1);
22194
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 Py_INCREF(Py_None); resultobj = Py_None;
22199 return resultobj;
22200 fail:
22201 return NULL;
22202 }
22203
22204
22205 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22206 PyObject *resultobj;
22207 wxIdleMode result;
22208 char *kwnames[] = {
22209 NULL
22210 };
22211
22212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22213 {
22214 PyThreadState* __tstate = wxPyBeginAllowThreads();
22215 result = (wxIdleMode)wxIdleEvent::GetMode();
22216
22217 wxPyEndAllowThreads(__tstate);
22218 if (PyErr_Occurred()) SWIG_fail;
22219 }
22220 resultobj = SWIG_From_int((result));
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxWindow *arg1 = (wxWindow *) 0 ;
22230 bool result;
22231 PyObject * obj0 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "win", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(1)) SWIG_fail;
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (bool)wxIdleEvent::CanSend(arg1);
22242
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 {
22247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22256 PyObject *obj;
22257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22258 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22259 Py_INCREF(obj);
22260 return Py_BuildValue((char *)"");
22261 }
22262 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj;
22264 int arg1 = (int) 0 ;
22265 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22266 wxPyEvent *result;
22267 PyObject * obj0 = 0 ;
22268 PyObject * obj1 = 0 ;
22269 char *kwnames[] = {
22270 (char *) "winid",(char *) "eventType", NULL
22271 };
22272
22273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22274 if (obj0) {
22275 {
22276 arg1 = (int)(SWIG_As_int(obj0));
22277 if (SWIG_arg_fail(1)) SWIG_fail;
22278 }
22279 }
22280 if (obj1) {
22281 {
22282 arg2 = (wxEventType)(SWIG_As_int(obj1));
22283 if (SWIG_arg_fail(2)) SWIG_fail;
22284 }
22285 }
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22289
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22294 return resultobj;
22295 fail:
22296 return NULL;
22297 }
22298
22299
22300 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22301 PyObject *resultobj;
22302 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22303 PyObject * obj0 = 0 ;
22304 char *kwnames[] = {
22305 (char *) "self", NULL
22306 };
22307
22308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22310 if (SWIG_arg_fail(1)) SWIG_fail;
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 delete arg1;
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 Py_INCREF(Py_None); resultobj = Py_None;
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22326 PyObject *resultobj;
22327 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22328 PyObject *arg2 = (PyObject *) 0 ;
22329 PyObject * obj0 = 0 ;
22330 PyObject * obj1 = 0 ;
22331 char *kwnames[] = {
22332 (char *) "self",(char *) "self", NULL
22333 };
22334
22335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22337 if (SWIG_arg_fail(1)) SWIG_fail;
22338 arg2 = obj1;
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 (arg1)->SetSelf(arg2);
22342
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 Py_INCREF(Py_None); resultobj = Py_None;
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22354 PyObject *resultobj;
22355 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22356 PyObject *result;
22357 PyObject * obj0 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 result = (PyObject *)(arg1)->GetSelf();
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 resultobj = result;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22380 PyObject *obj;
22381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22382 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22383 Py_INCREF(obj);
22384 return Py_BuildValue((char *)"");
22385 }
22386 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22387 PyObject *resultobj;
22388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22389 int arg2 = (int) 0 ;
22390 wxPyCommandEvent *result;
22391 PyObject * obj0 = 0 ;
22392 PyObject * obj1 = 0 ;
22393 char *kwnames[] = {
22394 (char *) "eventType",(char *) "id", NULL
22395 };
22396
22397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22398 if (obj0) {
22399 {
22400 arg1 = (wxEventType)(SWIG_As_int(obj0));
22401 if (SWIG_arg_fail(1)) SWIG_fail;
22402 }
22403 }
22404 if (obj1) {
22405 {
22406 arg2 = (int)(SWIG_As_int(obj1));
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 }
22409 }
22410 {
22411 PyThreadState* __tstate = wxPyBeginAllowThreads();
22412 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22413
22414 wxPyEndAllowThreads(__tstate);
22415 if (PyErr_Occurred()) SWIG_fail;
22416 }
22417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22418 return resultobj;
22419 fail:
22420 return NULL;
22421 }
22422
22423
22424 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22425 PyObject *resultobj;
22426 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22427 PyObject * obj0 = 0 ;
22428 char *kwnames[] = {
22429 (char *) "self", NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(1)) SWIG_fail;
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 delete arg1;
22438
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 Py_INCREF(Py_None); resultobj = Py_None;
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22450 PyObject *resultobj;
22451 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22452 PyObject *arg2 = (PyObject *) 0 ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char *kwnames[] = {
22456 (char *) "self",(char *) "self", NULL
22457 };
22458
22459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 arg2 = obj1;
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 (arg1)->SetSelf(arg2);
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 Py_INCREF(Py_None); resultobj = Py_None;
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22478 PyObject *resultobj;
22479 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22480 PyObject *result;
22481 PyObject * obj0 = 0 ;
22482 char *kwnames[] = {
22483 (char *) "self", NULL
22484 };
22485
22486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22488 if (SWIG_arg_fail(1)) SWIG_fail;
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (PyObject *)(arg1)->GetSelf();
22492
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 resultobj = result;
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22504 PyObject *obj;
22505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22506 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22507 Py_INCREF(obj);
22508 return Py_BuildValue((char *)"");
22509 }
22510 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22511 PyObject *resultobj;
22512 wxWindow *arg1 = (wxWindow *) 0 ;
22513 wxDateTime *arg2 = 0 ;
22514 wxEventType arg3 ;
22515 wxDateEvent *result;
22516 PyObject * obj0 = 0 ;
22517 PyObject * obj1 = 0 ;
22518 PyObject * obj2 = 0 ;
22519 char *kwnames[] = {
22520 (char *) "win",(char *) "dt",(char *) "type", NULL
22521 };
22522
22523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22528 if (SWIG_arg_fail(2)) SWIG_fail;
22529 if (arg2 == NULL) {
22530 SWIG_null_ref("wxDateTime");
22531 }
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 }
22534 {
22535 arg3 = (wxEventType)(SWIG_As_int(obj2));
22536 if (SWIG_arg_fail(3)) SWIG_fail;
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22553 PyObject *resultobj;
22554 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22555 wxDateTime *result;
22556 PyObject * obj0 = 0 ;
22557 char *kwnames[] = {
22558 (char *) "self", NULL
22559 };
22560
22561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(1)) SWIG_fail;
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 {
22567 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22568 result = (wxDateTime *) &_result_ref;
22569 }
22570
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22582 PyObject *resultobj;
22583 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22584 wxDateTime *arg2 = 0 ;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self",(char *) "date", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22596 if (SWIG_arg_fail(2)) SWIG_fail;
22597 if (arg2 == NULL) {
22598 SWIG_null_ref("wxDateTime");
22599 }
22600 if (SWIG_arg_fail(2)) SWIG_fail;
22601 }
22602 {
22603 PyThreadState* __tstate = wxPyBeginAllowThreads();
22604 (arg1)->SetDate((wxDateTime const &)*arg2);
22605
22606 wxPyEndAllowThreads(__tstate);
22607 if (PyErr_Occurred()) SWIG_fail;
22608 }
22609 Py_INCREF(Py_None); resultobj = Py_None;
22610 return resultobj;
22611 fail:
22612 return NULL;
22613 }
22614
22615
22616 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22617 PyObject *obj;
22618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22619 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22620 Py_INCREF(obj);
22621 return Py_BuildValue((char *)"");
22622 }
22623 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22624 PyObject *resultobj;
22625 wxPyApp *result;
22626 char *kwnames[] = {
22627 NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (wxPyApp *)new_wxPyApp();
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj;
22647 wxPyApp *arg1 = (wxPyApp *) 0 ;
22648 PyObject * obj0 = 0 ;
22649 char *kwnames[] = {
22650 (char *) "self", NULL
22651 };
22652
22653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22655 if (SWIG_arg_fail(1)) SWIG_fail;
22656 {
22657 PyThreadState* __tstate = wxPyBeginAllowThreads();
22658 delete arg1;
22659
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 Py_INCREF(Py_None); resultobj = Py_None;
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22671 PyObject *resultobj;
22672 wxPyApp *arg1 = (wxPyApp *) 0 ;
22673 PyObject *arg2 = (PyObject *) 0 ;
22674 PyObject *arg3 = (PyObject *) 0 ;
22675 bool arg4 ;
22676 PyObject * obj0 = 0 ;
22677 PyObject * obj1 = 0 ;
22678 PyObject * obj2 = 0 ;
22679 PyObject * obj3 = 0 ;
22680 char *kwnames[] = {
22681 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22682 };
22683
22684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22686 if (SWIG_arg_fail(1)) SWIG_fail;
22687 arg2 = obj1;
22688 arg3 = obj2;
22689 {
22690 arg4 = (bool)(SWIG_As_bool(obj3));
22691 if (SWIG_arg_fail(4)) SWIG_fail;
22692 }
22693 {
22694 PyThreadState* __tstate = wxPyBeginAllowThreads();
22695 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22696
22697 wxPyEndAllowThreads(__tstate);
22698 if (PyErr_Occurred()) SWIG_fail;
22699 }
22700 Py_INCREF(Py_None); resultobj = Py_None;
22701 return resultobj;
22702 fail:
22703 return NULL;
22704 }
22705
22706
22707 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22708 PyObject *resultobj;
22709 wxPyApp *arg1 = (wxPyApp *) 0 ;
22710 wxString result;
22711 PyObject * obj0 = 0 ;
22712 char *kwnames[] = {
22713 (char *) "self", NULL
22714 };
22715
22716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22718 if (SWIG_arg_fail(1)) SWIG_fail;
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 result = ((wxPyApp const *)arg1)->GetAppName();
22722
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 #if wxUSE_UNICODE
22728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22729 #else
22730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22731 #endif
22732 }
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22740 PyObject *resultobj;
22741 wxPyApp *arg1 = (wxPyApp *) 0 ;
22742 wxString *arg2 = 0 ;
22743 bool temp2 = false ;
22744 PyObject * obj0 = 0 ;
22745 PyObject * obj1 = 0 ;
22746 char *kwnames[] = {
22747 (char *) "self",(char *) "name", NULL
22748 };
22749
22750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22752 if (SWIG_arg_fail(1)) SWIG_fail;
22753 {
22754 arg2 = wxString_in_helper(obj1);
22755 if (arg2 == NULL) SWIG_fail;
22756 temp2 = true;
22757 }
22758 {
22759 PyThreadState* __tstate = wxPyBeginAllowThreads();
22760 (arg1)->SetAppName((wxString const &)*arg2);
22761
22762 wxPyEndAllowThreads(__tstate);
22763 if (PyErr_Occurred()) SWIG_fail;
22764 }
22765 Py_INCREF(Py_None); resultobj = Py_None;
22766 {
22767 if (temp2)
22768 delete arg2;
22769 }
22770 return resultobj;
22771 fail:
22772 {
22773 if (temp2)
22774 delete arg2;
22775 }
22776 return NULL;
22777 }
22778
22779
22780 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj;
22782 wxPyApp *arg1 = (wxPyApp *) 0 ;
22783 wxString result;
22784 PyObject * obj0 = 0 ;
22785 char *kwnames[] = {
22786 (char *) "self", NULL
22787 };
22788
22789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(1)) SWIG_fail;
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 result = ((wxPyApp const *)arg1)->GetClassName();
22795
22796 wxPyEndAllowThreads(__tstate);
22797 if (PyErr_Occurred()) SWIG_fail;
22798 }
22799 {
22800 #if wxUSE_UNICODE
22801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22802 #else
22803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22804 #endif
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22813 PyObject *resultobj;
22814 wxPyApp *arg1 = (wxPyApp *) 0 ;
22815 wxString *arg2 = 0 ;
22816 bool temp2 = false ;
22817 PyObject * obj0 = 0 ;
22818 PyObject * obj1 = 0 ;
22819 char *kwnames[] = {
22820 (char *) "self",(char *) "name", NULL
22821 };
22822
22823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22825 if (SWIG_arg_fail(1)) SWIG_fail;
22826 {
22827 arg2 = wxString_in_helper(obj1);
22828 if (arg2 == NULL) SWIG_fail;
22829 temp2 = true;
22830 }
22831 {
22832 PyThreadState* __tstate = wxPyBeginAllowThreads();
22833 (arg1)->SetClassName((wxString const &)*arg2);
22834
22835 wxPyEndAllowThreads(__tstate);
22836 if (PyErr_Occurred()) SWIG_fail;
22837 }
22838 Py_INCREF(Py_None); resultobj = Py_None;
22839 {
22840 if (temp2)
22841 delete arg2;
22842 }
22843 return resultobj;
22844 fail:
22845 {
22846 if (temp2)
22847 delete arg2;
22848 }
22849 return NULL;
22850 }
22851
22852
22853 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22854 PyObject *resultobj;
22855 wxPyApp *arg1 = (wxPyApp *) 0 ;
22856 wxString *result;
22857 PyObject * obj0 = 0 ;
22858 char *kwnames[] = {
22859 (char *) "self", NULL
22860 };
22861
22862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22864 if (SWIG_arg_fail(1)) SWIG_fail;
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 {
22868 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22869 result = (wxString *) &_result_ref;
22870 }
22871
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 #if wxUSE_UNICODE
22877 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22878 #else
22879 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22880 #endif
22881 }
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22889 PyObject *resultobj;
22890 wxPyApp *arg1 = (wxPyApp *) 0 ;
22891 wxString *arg2 = 0 ;
22892 bool temp2 = false ;
22893 PyObject * obj0 = 0 ;
22894 PyObject * obj1 = 0 ;
22895 char *kwnames[] = {
22896 (char *) "self",(char *) "name", NULL
22897 };
22898
22899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22901 if (SWIG_arg_fail(1)) SWIG_fail;
22902 {
22903 arg2 = wxString_in_helper(obj1);
22904 if (arg2 == NULL) SWIG_fail;
22905 temp2 = true;
22906 }
22907 {
22908 PyThreadState* __tstate = wxPyBeginAllowThreads();
22909 (arg1)->SetVendorName((wxString const &)*arg2);
22910
22911 wxPyEndAllowThreads(__tstate);
22912 if (PyErr_Occurred()) SWIG_fail;
22913 }
22914 Py_INCREF(Py_None); resultobj = Py_None;
22915 {
22916 if (temp2)
22917 delete arg2;
22918 }
22919 return resultobj;
22920 fail:
22921 {
22922 if (temp2)
22923 delete arg2;
22924 }
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj;
22931 wxPyApp *arg1 = (wxPyApp *) 0 ;
22932 wxAppTraits *result;
22933 PyObject * obj0 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(1)) SWIG_fail;
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (wxAppTraits *)(arg1)->GetTraits();
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj;
22957 wxPyApp *arg1 = (wxPyApp *) 0 ;
22958 PyObject * obj0 = 0 ;
22959 char *kwnames[] = {
22960 (char *) "self", NULL
22961 };
22962
22963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(1)) SWIG_fail;
22966 {
22967 PyThreadState* __tstate = wxPyBeginAllowThreads();
22968 (arg1)->ProcessPendingEvents();
22969
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 Py_INCREF(Py_None); resultobj = Py_None;
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22981 PyObject *resultobj;
22982 wxPyApp *arg1 = (wxPyApp *) 0 ;
22983 bool arg2 = (bool) false ;
22984 bool result;
22985 PyObject * obj0 = 0 ;
22986 PyObject * obj1 = 0 ;
22987 char *kwnames[] = {
22988 (char *) "self",(char *) "onlyIfNeeded", NULL
22989 };
22990
22991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22993 if (SWIG_arg_fail(1)) SWIG_fail;
22994 if (obj1) {
22995 {
22996 arg2 = (bool)(SWIG_As_bool(obj1));
22997 if (SWIG_arg_fail(2)) SWIG_fail;
22998 }
22999 }
23000 {
23001 PyThreadState* __tstate = wxPyBeginAllowThreads();
23002 result = (bool)(arg1)->Yield(arg2);
23003
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 {
23008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23009 }
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj;
23018 wxPyApp *arg1 = (wxPyApp *) 0 ;
23019 PyObject * obj0 = 0 ;
23020 char *kwnames[] = {
23021 (char *) "self", NULL
23022 };
23023
23024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23026 if (SWIG_arg_fail(1)) SWIG_fail;
23027 {
23028 PyThreadState* __tstate = wxPyBeginAllowThreads();
23029 (arg1)->WakeUpIdle();
23030
23031 wxPyEndAllowThreads(__tstate);
23032 if (PyErr_Occurred()) SWIG_fail;
23033 }
23034 Py_INCREF(Py_None); resultobj = Py_None;
23035 return resultobj;
23036 fail:
23037 return NULL;
23038 }
23039
23040
23041 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23042 PyObject *resultobj;
23043 bool result;
23044 char *kwnames[] = {
23045 NULL
23046 };
23047
23048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)wxPyApp::IsMainLoopRunning();
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 {
23057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23058 }
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23066 PyObject *resultobj;
23067 wxPyApp *arg1 = (wxPyApp *) 0 ;
23068 int result;
23069 PyObject * obj0 = 0 ;
23070 char *kwnames[] = {
23071 (char *) "self", NULL
23072 };
23073
23074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23076 if (SWIG_arg_fail(1)) SWIG_fail;
23077 {
23078 PyThreadState* __tstate = wxPyBeginAllowThreads();
23079 result = (int)(arg1)->MainLoop();
23080
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 {
23085 resultobj = SWIG_From_int((int)(result));
23086 }
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxPyApp *arg1 = (wxPyApp *) 0 ;
23096 PyObject * obj0 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 (arg1)->Exit();
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 Py_INCREF(Py_None); resultobj = Py_None;
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23119 PyObject *resultobj;
23120 wxPyApp *arg1 = (wxPyApp *) 0 ;
23121 PyObject * obj0 = 0 ;
23122 char *kwnames[] = {
23123 (char *) "self", NULL
23124 };
23125
23126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23128 if (SWIG_arg_fail(1)) SWIG_fail;
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 (arg1)->ExitMainLoop();
23132
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 Py_INCREF(Py_None); resultobj = Py_None;
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23144 PyObject *resultobj;
23145 wxPyApp *arg1 = (wxPyApp *) 0 ;
23146 bool result;
23147 PyObject * obj0 = 0 ;
23148 char *kwnames[] = {
23149 (char *) "self", NULL
23150 };
23151
23152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23154 if (SWIG_arg_fail(1)) SWIG_fail;
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 result = (bool)(arg1)->Pending();
23158
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23164 }
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23172 PyObject *resultobj;
23173 wxPyApp *arg1 = (wxPyApp *) 0 ;
23174 bool result;
23175 PyObject * obj0 = 0 ;
23176 char *kwnames[] = {
23177 (char *) "self", NULL
23178 };
23179
23180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23182 if (SWIG_arg_fail(1)) SWIG_fail;
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 result = (bool)(arg1)->Dispatch();
23186
23187 wxPyEndAllowThreads(__tstate);
23188 if (PyErr_Occurred()) SWIG_fail;
23189 }
23190 {
23191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23192 }
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23200 PyObject *resultobj;
23201 wxPyApp *arg1 = (wxPyApp *) 0 ;
23202 bool result;
23203 PyObject * obj0 = 0 ;
23204 char *kwnames[] = {
23205 (char *) "self", NULL
23206 };
23207
23208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23210 if (SWIG_arg_fail(1)) SWIG_fail;
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = (bool)(arg1)->ProcessIdle();
23214
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23220 }
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23228 PyObject *resultobj;
23229 wxPyApp *arg1 = (wxPyApp *) 0 ;
23230 wxWindow *arg2 = (wxWindow *) 0 ;
23231 wxIdleEvent *arg3 = 0 ;
23232 bool result;
23233 PyObject * obj0 = 0 ;
23234 PyObject * obj1 = 0 ;
23235 PyObject * obj2 = 0 ;
23236 char *kwnames[] = {
23237 (char *) "self",(char *) "win",(char *) "event", NULL
23238 };
23239
23240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23242 if (SWIG_arg_fail(1)) SWIG_fail;
23243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23244 if (SWIG_arg_fail(2)) SWIG_fail;
23245 {
23246 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23247 if (SWIG_arg_fail(3)) SWIG_fail;
23248 if (arg3 == NULL) {
23249 SWIG_null_ref("wxIdleEvent");
23250 }
23251 if (SWIG_arg_fail(3)) SWIG_fail;
23252 }
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23256
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 {
23261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23262 }
23263 return resultobj;
23264 fail:
23265 return NULL;
23266 }
23267
23268
23269 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23270 PyObject *resultobj;
23271 wxPyApp *arg1 = (wxPyApp *) 0 ;
23272 bool result;
23273 PyObject * obj0 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = (bool)((wxPyApp const *)arg1)->IsActive();
23284
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 {
23289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23290 }
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23298 PyObject *resultobj;
23299 wxPyApp *arg1 = (wxPyApp *) 0 ;
23300 wxWindow *arg2 = (wxWindow *) 0 ;
23301 PyObject * obj0 = 0 ;
23302 PyObject * obj1 = 0 ;
23303 char *kwnames[] = {
23304 (char *) "self",(char *) "win", NULL
23305 };
23306
23307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(1)) SWIG_fail;
23310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23311 if (SWIG_arg_fail(2)) SWIG_fail;
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 (arg1)->SetTopWindow(arg2);
23315
23316 wxPyEndAllowThreads(__tstate);
23317 if (PyErr_Occurred()) SWIG_fail;
23318 }
23319 Py_INCREF(Py_None); resultobj = Py_None;
23320 return resultobj;
23321 fail:
23322 return NULL;
23323 }
23324
23325
23326 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23327 PyObject *resultobj;
23328 wxPyApp *arg1 = (wxPyApp *) 0 ;
23329 wxWindow *result;
23330 PyObject * obj0 = 0 ;
23331 char *kwnames[] = {
23332 (char *) "self", NULL
23333 };
23334
23335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23337 if (SWIG_arg_fail(1)) SWIG_fail;
23338 {
23339 PyThreadState* __tstate = wxPyBeginAllowThreads();
23340 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23341
23342 wxPyEndAllowThreads(__tstate);
23343 if (PyErr_Occurred()) SWIG_fail;
23344 }
23345 {
23346 resultobj = wxPyMake_wxObject(result, 0);
23347 }
23348 return resultobj;
23349 fail:
23350 return NULL;
23351 }
23352
23353
23354 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23355 PyObject *resultobj;
23356 wxPyApp *arg1 = (wxPyApp *) 0 ;
23357 bool arg2 ;
23358 PyObject * obj0 = 0 ;
23359 PyObject * obj1 = 0 ;
23360 char *kwnames[] = {
23361 (char *) "self",(char *) "flag", NULL
23362 };
23363
23364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 {
23368 arg2 = (bool)(SWIG_As_bool(obj1));
23369 if (SWIG_arg_fail(2)) SWIG_fail;
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 (arg1)->SetExitOnFrameDelete(arg2);
23374
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 Py_INCREF(Py_None); resultobj = Py_None;
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 wxPyApp *arg1 = (wxPyApp *) 0 ;
23388 bool result;
23389 PyObject * obj0 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23400
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 {
23405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23406 }
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj;
23415 wxPyApp *arg1 = (wxPyApp *) 0 ;
23416 bool arg2 ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 char *kwnames[] = {
23420 (char *) "self",(char *) "flag", NULL
23421 };
23422
23423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23425 if (SWIG_arg_fail(1)) SWIG_fail;
23426 {
23427 arg2 = (bool)(SWIG_As_bool(obj1));
23428 if (SWIG_arg_fail(2)) SWIG_fail;
23429 }
23430 {
23431 PyThreadState* __tstate = wxPyBeginAllowThreads();
23432 (arg1)->SetUseBestVisual(arg2);
23433
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 Py_INCREF(Py_None); resultobj = Py_None;
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj;
23446 wxPyApp *arg1 = (wxPyApp *) 0 ;
23447 bool result;
23448 PyObject * obj0 = 0 ;
23449 char *kwnames[] = {
23450 (char *) "self", NULL
23451 };
23452
23453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23455 if (SWIG_arg_fail(1)) SWIG_fail;
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23459
23460 wxPyEndAllowThreads(__tstate);
23461 if (PyErr_Occurred()) SWIG_fail;
23462 }
23463 {
23464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23465 }
23466 return resultobj;
23467 fail:
23468 return NULL;
23469 }
23470
23471
23472 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23473 PyObject *resultobj;
23474 wxPyApp *arg1 = (wxPyApp *) 0 ;
23475 int arg2 ;
23476 PyObject * obj0 = 0 ;
23477 PyObject * obj1 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self",(char *) "mode", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 arg2 = (int)(SWIG_As_int(obj1));
23487 if (SWIG_arg_fail(2)) SWIG_fail;
23488 }
23489 {
23490 PyThreadState* __tstate = wxPyBeginAllowThreads();
23491 (arg1)->SetPrintMode(arg2);
23492
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 Py_INCREF(Py_None); resultobj = Py_None;
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23504 PyObject *resultobj;
23505 wxPyApp *arg1 = (wxPyApp *) 0 ;
23506 int result;
23507 PyObject * obj0 = 0 ;
23508 char *kwnames[] = {
23509 (char *) "self", NULL
23510 };
23511
23512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23514 if (SWIG_arg_fail(1)) SWIG_fail;
23515 {
23516 PyThreadState* __tstate = wxPyBeginAllowThreads();
23517 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23518
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 {
23523 resultobj = SWIG_From_int((int)(result));
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj;
23533 wxPyApp *arg1 = (wxPyApp *) 0 ;
23534 int arg2 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char *kwnames[] = {
23538 (char *) "self",(char *) "mode", NULL
23539 };
23540
23541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23543 if (SWIG_arg_fail(1)) SWIG_fail;
23544 {
23545 arg2 = (int)(SWIG_As_int(obj1));
23546 if (SWIG_arg_fail(2)) SWIG_fail;
23547 }
23548 {
23549 PyThreadState* __tstate = wxPyBeginAllowThreads();
23550 (arg1)->SetAssertMode(arg2);
23551
23552 wxPyEndAllowThreads(__tstate);
23553 if (PyErr_Occurred()) SWIG_fail;
23554 }
23555 Py_INCREF(Py_None); resultobj = Py_None;
23556 return resultobj;
23557 fail:
23558 return NULL;
23559 }
23560
23561
23562 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23563 PyObject *resultobj;
23564 wxPyApp *arg1 = (wxPyApp *) 0 ;
23565 int result;
23566 PyObject * obj0 = 0 ;
23567 char *kwnames[] = {
23568 (char *) "self", NULL
23569 };
23570
23571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23573 if (SWIG_arg_fail(1)) SWIG_fail;
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (int)(arg1)->GetAssertMode();
23577
23578 wxPyEndAllowThreads(__tstate);
23579 if (PyErr_Occurred()) SWIG_fail;
23580 }
23581 {
23582 resultobj = SWIG_From_int((int)(result));
23583 }
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23591 PyObject *resultobj;
23592 bool result;
23593 char *kwnames[] = {
23594 NULL
23595 };
23596
23597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23601
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 {
23606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23607 }
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj;
23616 long result;
23617 char *kwnames[] = {
23618 NULL
23619 };
23620
23621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (long)wxPyApp::GetMacAboutMenuItemId();
23625
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = SWIG_From_long((long)(result));
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 long result;
23641 char *kwnames[] = {
23642 NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = SWIG_From_long((long)(result));
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj;
23664 long result;
23665 char *kwnames[] = {
23666 NULL
23667 };
23668
23669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (long)wxPyApp::GetMacExitMenuItemId();
23673
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = SWIG_From_long((long)(result));
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 wxString result;
23689 char *kwnames[] = {
23690 NULL
23691 };
23692
23693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23694 {
23695 PyThreadState* __tstate = wxPyBeginAllowThreads();
23696 result = wxPyApp::GetMacHelpMenuTitleName();
23697
23698 wxPyEndAllowThreads(__tstate);
23699 if (PyErr_Occurred()) SWIG_fail;
23700 }
23701 {
23702 #if wxUSE_UNICODE
23703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23704 #else
23705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23706 #endif
23707 }
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23715 PyObject *resultobj;
23716 bool arg1 ;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "val", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23723 {
23724 arg1 = (bool)(SWIG_As_bool(obj0));
23725 if (SWIG_arg_fail(1)) SWIG_fail;
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 Py_INCREF(Py_None); resultobj = Py_None;
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj;
23743 long arg1 ;
23744 PyObject * obj0 = 0 ;
23745 char *kwnames[] = {
23746 (char *) "val", NULL
23747 };
23748
23749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23750 {
23751 arg1 = (long)(SWIG_As_long(obj0));
23752 if (SWIG_arg_fail(1)) SWIG_fail;
23753 }
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 wxPyApp::SetMacAboutMenuItemId(arg1);
23757
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 Py_INCREF(Py_None); resultobj = Py_None;
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj;
23770 long arg1 ;
23771 PyObject * obj0 = 0 ;
23772 char *kwnames[] = {
23773 (char *) "val", NULL
23774 };
23775
23776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23777 {
23778 arg1 = (long)(SWIG_As_long(obj0));
23779 if (SWIG_arg_fail(1)) SWIG_fail;
23780 }
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 Py_INCREF(Py_None); resultobj = Py_None;
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj;
23797 long arg1 ;
23798 PyObject * obj0 = 0 ;
23799 char *kwnames[] = {
23800 (char *) "val", NULL
23801 };
23802
23803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23804 {
23805 arg1 = (long)(SWIG_As_long(obj0));
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 }
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 wxPyApp::SetMacExitMenuItemId(arg1);
23811
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 Py_INCREF(Py_None); resultobj = Py_None;
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj;
23824 wxString *arg1 = 0 ;
23825 bool temp1 = false ;
23826 PyObject * obj0 = 0 ;
23827 char *kwnames[] = {
23828 (char *) "val", NULL
23829 };
23830
23831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23832 {
23833 arg1 = wxString_in_helper(obj0);
23834 if (arg1 == NULL) SWIG_fail;
23835 temp1 = true;
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 Py_INCREF(Py_None); resultobj = Py_None;
23845 {
23846 if (temp1)
23847 delete arg1;
23848 }
23849 return resultobj;
23850 fail:
23851 {
23852 if (temp1)
23853 delete arg1;
23854 }
23855 return NULL;
23856 }
23857
23858
23859 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj;
23861 wxPyApp *arg1 = (wxPyApp *) 0 ;
23862 PyObject * obj0 = 0 ;
23863 char *kwnames[] = {
23864 (char *) "self", NULL
23865 };
23866
23867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23869 if (SWIG_arg_fail(1)) SWIG_fail;
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 (arg1)->_BootstrapApp();
23873
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 Py_INCREF(Py_None); resultobj = Py_None;
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23885 PyObject *resultobj;
23886 int result;
23887 char *kwnames[] = {
23888 NULL
23889 };
23890
23891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = (int)wxPyApp::GetComCtl32Version();
23895
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 resultobj = SWIG_From_int((int)(result));
23901 }
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23909 PyObject *obj;
23910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23911 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23912 Py_INCREF(obj);
23913 return Py_BuildValue((char *)"");
23914 }
23915 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 char *kwnames[] = {
23918 NULL
23919 };
23920
23921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 wxExit();
23925
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 Py_INCREF(Py_None); resultobj = Py_None;
23930 return resultobj;
23931 fail:
23932 return NULL;
23933 }
23934
23935
23936 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23937 PyObject *resultobj;
23938 bool result;
23939 char *kwnames[] = {
23940 NULL
23941 };
23942
23943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (bool)wxYield();
23947
23948 wxPyEndAllowThreads(__tstate);
23949 if (PyErr_Occurred()) SWIG_fail;
23950 }
23951 {
23952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23953 }
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 bool result;
23963 char *kwnames[] = {
23964 NULL
23965 };
23966
23967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 result = (bool)wxYieldIfNeeded();
23971
23972 wxPyEndAllowThreads(__tstate);
23973 if (PyErr_Occurred()) SWIG_fail;
23974 }
23975 {
23976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23977 }
23978 return resultobj;
23979 fail:
23980 return NULL;
23981 }
23982
23983
23984 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23985 PyObject *resultobj;
23986 wxWindow *arg1 = (wxWindow *) NULL ;
23987 bool arg2 = (bool) false ;
23988 bool result;
23989 PyObject * obj0 = 0 ;
23990 PyObject * obj1 = 0 ;
23991 char *kwnames[] = {
23992 (char *) "win",(char *) "onlyIfNeeded", NULL
23993 };
23994
23995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23996 if (obj0) {
23997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23998 if (SWIG_arg_fail(1)) SWIG_fail;
23999 }
24000 if (obj1) {
24001 {
24002 arg2 = (bool)(SWIG_As_bool(obj1));
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 }
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (bool)wxSafeYield(arg1,arg2);
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24023 PyObject *resultobj;
24024 char *kwnames[] = {
24025 NULL
24026 };
24027
24028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24029 {
24030 PyThreadState* __tstate = wxPyBeginAllowThreads();
24031 wxWakeUpIdle();
24032
24033 wxPyEndAllowThreads(__tstate);
24034 if (PyErr_Occurred()) SWIG_fail;
24035 }
24036 Py_INCREF(Py_None); resultobj = Py_None;
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24044 PyObject *resultobj;
24045 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24046 wxEvent *arg2 = 0 ;
24047 PyObject * obj0 = 0 ;
24048 PyObject * obj1 = 0 ;
24049 char *kwnames[] = {
24050 (char *) "dest",(char *) "event", NULL
24051 };
24052
24053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24055 if (SWIG_arg_fail(1)) SWIG_fail;
24056 {
24057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24058 if (SWIG_arg_fail(2)) SWIG_fail;
24059 if (arg2 == NULL) {
24060 SWIG_null_ref("wxEvent");
24061 }
24062 if (SWIG_arg_fail(2)) SWIG_fail;
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 wxPostEvent(arg1,*arg2);
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 Py_INCREF(Py_None); resultobj = Py_None;
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj;
24080 char *kwnames[] = {
24081 NULL
24082 };
24083
24084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 wxApp_CleanUp();
24088
24089 wxPyEndAllowThreads(__tstate);
24090 if (PyErr_Occurred()) SWIG_fail;
24091 }
24092 Py_INCREF(Py_None); resultobj = Py_None;
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24100 PyObject *resultobj;
24101 wxPyApp *result;
24102 char *kwnames[] = {
24103 NULL
24104 };
24105
24106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 result = (wxPyApp *)wxPyGetApp();
24110
24111 wxPyEndAllowThreads(__tstate);
24112 if (PyErr_Occurred()) SWIG_fail;
24113 }
24114 {
24115 resultobj = wxPyMake_wxObject(result, 0);
24116 }
24117 return resultobj;
24118 fail:
24119 return NULL;
24120 }
24121
24122
24123 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24124 PyObject *resultobj;
24125 char *arg1 = (char *) 0 ;
24126 PyObject * obj0 = 0 ;
24127 char *kwnames[] = {
24128 (char *) "encoding", NULL
24129 };
24130
24131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24132 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24133 SWIG_arg_fail(1);SWIG_fail;
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 wxSetDefaultPyEncoding((char const *)arg1);
24138
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 Py_INCREF(Py_None); resultobj = Py_None;
24143 return resultobj;
24144 fail:
24145 return NULL;
24146 }
24147
24148
24149 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24150 PyObject *resultobj;
24151 char *result;
24152 char *kwnames[] = {
24153 NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (char *)wxGetDefaultPyEncoding();
24160
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 resultobj = SWIG_FromCharPtr(result);
24165 return resultobj;
24166 fail:
24167 return NULL;
24168 }
24169
24170
24171 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24172 PyObject *resultobj;
24173 wxEventLoop *result;
24174 char *kwnames[] = {
24175 NULL
24176 };
24177
24178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24179 {
24180 PyThreadState* __tstate = wxPyBeginAllowThreads();
24181 result = (wxEventLoop *)new wxEventLoop();
24182
24183 wxPyEndAllowThreads(__tstate);
24184 if (PyErr_Occurred()) SWIG_fail;
24185 }
24186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24187 return resultobj;
24188 fail:
24189 return NULL;
24190 }
24191
24192
24193 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24194 PyObject *resultobj;
24195 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24196 PyObject * obj0 = 0 ;
24197 char *kwnames[] = {
24198 (char *) "self", NULL
24199 };
24200
24201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24203 if (SWIG_arg_fail(1)) SWIG_fail;
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 delete arg1;
24207
24208 wxPyEndAllowThreads(__tstate);
24209 if (PyErr_Occurred()) SWIG_fail;
24210 }
24211 Py_INCREF(Py_None); resultobj = Py_None;
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24221 int result;
24222 PyObject * obj0 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (int)(arg1)->Run();
24233
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 resultobj = SWIG_From_int((int)(result));
24239 }
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj;
24248 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24249 int arg2 = (int) 0 ;
24250 PyObject * obj0 = 0 ;
24251 PyObject * obj1 = 0 ;
24252 char *kwnames[] = {
24253 (char *) "self",(char *) "rc", NULL
24254 };
24255
24256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24258 if (SWIG_arg_fail(1)) SWIG_fail;
24259 if (obj1) {
24260 {
24261 arg2 = (int)(SWIG_As_int(obj1));
24262 if (SWIG_arg_fail(2)) SWIG_fail;
24263 }
24264 }
24265 {
24266 PyThreadState* __tstate = wxPyBeginAllowThreads();
24267 (arg1)->Exit(arg2);
24268
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 Py_INCREF(Py_None); resultobj = Py_None;
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj;
24281 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24282 bool result;
24283 PyObject * obj0 = 0 ;
24284 char *kwnames[] = {
24285 (char *) "self", NULL
24286 };
24287
24288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24290 if (SWIG_arg_fail(1)) SWIG_fail;
24291 {
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 result = (bool)((wxEventLoop const *)arg1)->Pending();
24294
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 {
24299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24300 }
24301 return resultobj;
24302 fail:
24303 return NULL;
24304 }
24305
24306
24307 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj;
24309 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24310 bool result;
24311 PyObject * obj0 = 0 ;
24312 char *kwnames[] = {
24313 (char *) "self", NULL
24314 };
24315
24316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24318 if (SWIG_arg_fail(1)) SWIG_fail;
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 result = (bool)(arg1)->Dispatch();
24322
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 {
24327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24338 bool result;
24339 PyObject * obj0 = 0 ;
24340 char *kwnames[] = {
24341 (char *) "self", NULL
24342 };
24343
24344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24350
24351 wxPyEndAllowThreads(__tstate);
24352 if (PyErr_Occurred()) SWIG_fail;
24353 }
24354 {
24355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24356 }
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj;
24365 wxEventLoop *result;
24366 char *kwnames[] = {
24367 NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24371 {
24372 PyThreadState* __tstate = wxPyBeginAllowThreads();
24373 result = (wxEventLoop *)wxEventLoop::GetActive();
24374
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24386 PyObject *resultobj;
24387 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24388 PyObject * obj0 = 0 ;
24389 char *kwnames[] = {
24390 (char *) "loop", NULL
24391 };
24392
24393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(1)) SWIG_fail;
24396 {
24397 PyThreadState* __tstate = wxPyBeginAllowThreads();
24398 wxEventLoop::SetActive(arg1);
24399
24400 wxPyEndAllowThreads(__tstate);
24401 if (PyErr_Occurred()) SWIG_fail;
24402 }
24403 Py_INCREF(Py_None); resultobj = Py_None;
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24411 PyObject *obj;
24412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24413 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24414 Py_INCREF(obj);
24415 return Py_BuildValue((char *)"");
24416 }
24417 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24418 PyObject *resultobj;
24419 int arg1 = (int) 0 ;
24420 int arg2 = (int) 0 ;
24421 int arg3 = (int) 0 ;
24422 wxAcceleratorEntry *result;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 PyObject * obj2 = 0 ;
24426 char *kwnames[] = {
24427 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24428 };
24429
24430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24431 if (obj0) {
24432 {
24433 arg1 = (int)(SWIG_As_int(obj0));
24434 if (SWIG_arg_fail(1)) SWIG_fail;
24435 }
24436 }
24437 if (obj1) {
24438 {
24439 arg2 = (int)(SWIG_As_int(obj1));
24440 if (SWIG_arg_fail(2)) SWIG_fail;
24441 }
24442 }
24443 if (obj2) {
24444 {
24445 arg3 = (int)(SWIG_As_int(obj2));
24446 if (SWIG_arg_fail(3)) SWIG_fail;
24447 }
24448 }
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24452
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24466 PyObject * obj0 = 0 ;
24467 char *kwnames[] = {
24468 (char *) "self", NULL
24469 };
24470
24471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24473 if (SWIG_arg_fail(1)) SWIG_fail;
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 delete arg1;
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 Py_INCREF(Py_None); resultobj = Py_None;
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24489 PyObject *resultobj;
24490 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24491 int arg2 ;
24492 int arg3 ;
24493 int arg4 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 PyObject * obj2 = 0 ;
24497 PyObject * obj3 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 {
24506 arg2 = (int)(SWIG_As_int(obj1));
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 }
24509 {
24510 arg3 = (int)(SWIG_As_int(obj2));
24511 if (SWIG_arg_fail(3)) SWIG_fail;
24512 }
24513 {
24514 arg4 = (int)(SWIG_As_int(obj3));
24515 if (SWIG_arg_fail(4)) SWIG_fail;
24516 }
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 (arg1)->Set(arg2,arg3,arg4);
24520
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 Py_INCREF(Py_None); resultobj = Py_None;
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24532 PyObject *resultobj;
24533 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24534 int result;
24535 PyObject * obj0 = 0 ;
24536 char *kwnames[] = {
24537 (char *) "self", NULL
24538 };
24539
24540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24542 if (SWIG_arg_fail(1)) SWIG_fail;
24543 {
24544 PyThreadState* __tstate = wxPyBeginAllowThreads();
24545 result = (int)(arg1)->GetFlags();
24546
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 {
24551 resultobj = SWIG_From_int((int)(result));
24552 }
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24560 PyObject *resultobj;
24561 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24562 int result;
24563 PyObject * obj0 = 0 ;
24564 char *kwnames[] = {
24565 (char *) "self", NULL
24566 };
24567
24568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24570 if (SWIG_arg_fail(1)) SWIG_fail;
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (int)(arg1)->GetKeyCode();
24574
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = SWIG_From_int((int)(result));
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj;
24589 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24590 int result;
24591 PyObject * obj0 = 0 ;
24592 char *kwnames[] = {
24593 (char *) "self", NULL
24594 };
24595
24596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24598 if (SWIG_arg_fail(1)) SWIG_fail;
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (int)(arg1)->GetCommand();
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = SWIG_From_int((int)(result));
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24616 PyObject *obj;
24617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24618 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24619 Py_INCREF(obj);
24620 return Py_BuildValue((char *)"");
24621 }
24622 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24623 PyObject *resultobj;
24624 int arg1 ;
24625 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24626 wxAcceleratorTable *result;
24627 PyObject * obj0 = 0 ;
24628 char *kwnames[] = {
24629 (char *) "n", NULL
24630 };
24631
24632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24633 {
24634 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24635 if (arg2) arg1 = PyList_Size(obj0);
24636 else arg1 = 0;
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24646 {
24647 delete [] arg2;
24648 }
24649 return resultobj;
24650 fail:
24651 {
24652 delete [] arg2;
24653 }
24654 return NULL;
24655 }
24656
24657
24658 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24659 PyObject *resultobj;
24660 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24661 PyObject * obj0 = 0 ;
24662 char *kwnames[] = {
24663 (char *) "self", NULL
24664 };
24665
24666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24668 if (SWIG_arg_fail(1)) SWIG_fail;
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 delete arg1;
24672
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 Py_INCREF(Py_None); resultobj = Py_None;
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj;
24685 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24686 bool result;
24687 PyObject * obj0 = 0 ;
24688 char *kwnames[] = {
24689 (char *) "self", NULL
24690 };
24691
24692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(1)) SWIG_fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 {
24703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24704 }
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24712 PyObject *obj;
24713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24714 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24715 Py_INCREF(obj);
24716 return Py_BuildValue((char *)"");
24717 }
24718 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24719 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24720 return 1;
24721 }
24722
24723
24724 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24725 PyObject *pyobj;
24726
24727 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24728 return pyobj;
24729 }
24730
24731
24732 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxString *arg1 = 0 ;
24735 wxAcceleratorEntry *result;
24736 bool temp1 = false ;
24737 PyObject * obj0 = 0 ;
24738 char *kwnames[] = {
24739 (char *) "label", NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24743 {
24744 arg1 = wxString_in_helper(obj0);
24745 if (arg1 == NULL) SWIG_fail;
24746 temp1 = true;
24747 }
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24756 {
24757 if (temp1)
24758 delete arg1;
24759 }
24760 return resultobj;
24761 fail:
24762 {
24763 if (temp1)
24764 delete arg1;
24765 }
24766 return NULL;
24767 }
24768
24769
24770 static int _wrap_PanelNameStr_set(PyObject *) {
24771 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24772 return 1;
24773 }
24774
24775
24776 static PyObject *_wrap_PanelNameStr_get(void) {
24777 PyObject *pyobj;
24778
24779 {
24780 #if wxUSE_UNICODE
24781 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24782 #else
24783 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24784 #endif
24785 }
24786 return pyobj;
24787 }
24788
24789
24790 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj;
24792 wxVisualAttributes *result;
24793 char *kwnames[] = {
24794 NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 result = (wxVisualAttributes *)new_wxVisualAttributes();
24801
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj;
24814 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24815 PyObject * obj0 = 0 ;
24816 char *kwnames[] = {
24817 (char *) "self", NULL
24818 };
24819
24820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(1)) SWIG_fail;
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 delete_wxVisualAttributes(arg1);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 Py_INCREF(Py_None); resultobj = Py_None;
24831 return resultobj;
24832 fail:
24833 return NULL;
24834 }
24835
24836
24837 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj;
24839 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24840 wxFont *arg2 = (wxFont *) 0 ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char *kwnames[] = {
24844 (char *) "self",(char *) "font", NULL
24845 };
24846
24847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(1)) SWIG_fail;
24850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24851 if (SWIG_arg_fail(2)) SWIG_fail;
24852 if (arg1) (arg1)->font = *arg2;
24853
24854 Py_INCREF(Py_None); resultobj = Py_None;
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj;
24863 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24864 wxFont *result;
24865 PyObject * obj0 = 0 ;
24866 char *kwnames[] = {
24867 (char *) "self", NULL
24868 };
24869
24870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24872 if (SWIG_arg_fail(1)) SWIG_fail;
24873 result = (wxFont *)& ((arg1)->font);
24874
24875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj;
24884 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24885 wxColour *arg2 = (wxColour *) 0 ;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "self",(char *) "colFg", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24896 if (SWIG_arg_fail(2)) SWIG_fail;
24897 if (arg1) (arg1)->colFg = *arg2;
24898
24899 Py_INCREF(Py_None); resultobj = Py_None;
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj;
24908 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24909 wxColour *result;
24910 PyObject * obj0 = 0 ;
24911 char *kwnames[] = {
24912 (char *) "self", NULL
24913 };
24914
24915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24917 if (SWIG_arg_fail(1)) SWIG_fail;
24918 result = (wxColour *)& ((arg1)->colFg);
24919
24920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj;
24929 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24930 wxColour *arg2 = (wxColour *) 0 ;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self",(char *) "colBg", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24941 if (SWIG_arg_fail(2)) SWIG_fail;
24942 if (arg1) (arg1)->colBg = *arg2;
24943
24944 Py_INCREF(Py_None); resultobj = Py_None;
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj;
24953 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24954 wxColour *result;
24955 PyObject * obj0 = 0 ;
24956 char *kwnames[] = {
24957 (char *) "self", NULL
24958 };
24959
24960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24962 if (SWIG_arg_fail(1)) SWIG_fail;
24963 result = (wxColour *)& ((arg1)->colBg);
24964
24965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24973 PyObject *obj;
24974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24975 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24976 Py_INCREF(obj);
24977 return Py_BuildValue((char *)"");
24978 }
24979 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj;
24981 wxWindow *arg1 = (wxWindow *) 0 ;
24982 int arg2 = (int) (int)-1 ;
24983 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24984 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24985 wxSize const &arg4_defvalue = wxDefaultSize ;
24986 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24987 long arg5 = (long) 0 ;
24988 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24989 wxString *arg6 = (wxString *) &arg6_defvalue ;
24990 wxWindow *result;
24991 wxPoint temp3 ;
24992 wxSize temp4 ;
24993 bool temp6 = false ;
24994 PyObject * obj0 = 0 ;
24995 PyObject * obj1 = 0 ;
24996 PyObject * obj2 = 0 ;
24997 PyObject * obj3 = 0 ;
24998 PyObject * obj4 = 0 ;
24999 PyObject * obj5 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25006 if (SWIG_arg_fail(1)) SWIG_fail;
25007 if (obj1) {
25008 {
25009 arg2 = (int const)(SWIG_As_int(obj1));
25010 if (SWIG_arg_fail(2)) SWIG_fail;
25011 }
25012 }
25013 if (obj2) {
25014 {
25015 arg3 = &temp3;
25016 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25017 }
25018 }
25019 if (obj3) {
25020 {
25021 arg4 = &temp4;
25022 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25023 }
25024 }
25025 if (obj4) {
25026 {
25027 arg5 = (long)(SWIG_As_long(obj4));
25028 if (SWIG_arg_fail(5)) SWIG_fail;
25029 }
25030 }
25031 if (obj5) {
25032 {
25033 arg6 = wxString_in_helper(obj5);
25034 if (arg6 == NULL) SWIG_fail;
25035 temp6 = true;
25036 }
25037 }
25038 {
25039 if (!wxPyCheckForApp()) SWIG_fail;
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25042
25043 wxPyEndAllowThreads(__tstate);
25044 if (PyErr_Occurred()) SWIG_fail;
25045 }
25046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25047 {
25048 if (temp6)
25049 delete arg6;
25050 }
25051 return resultobj;
25052 fail:
25053 {
25054 if (temp6)
25055 delete arg6;
25056 }
25057 return NULL;
25058 }
25059
25060
25061 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj;
25063 wxWindow *result;
25064 char *kwnames[] = {
25065 NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25069 {
25070 if (!wxPyCheckForApp()) SWIG_fail;
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (wxWindow *)new wxWindow();
25073
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25078 return resultobj;
25079 fail:
25080 return NULL;
25081 }
25082
25083
25084 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25085 PyObject *resultobj;
25086 wxWindow *arg1 = (wxWindow *) 0 ;
25087 wxWindow *arg2 = (wxWindow *) 0 ;
25088 int arg3 = (int) (int)-1 ;
25089 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25090 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25091 wxSize const &arg5_defvalue = wxDefaultSize ;
25092 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25093 long arg6 = (long) 0 ;
25094 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25095 wxString *arg7 = (wxString *) &arg7_defvalue ;
25096 bool result;
25097 wxPoint temp4 ;
25098 wxSize temp5 ;
25099 bool temp7 = false ;
25100 PyObject * obj0 = 0 ;
25101 PyObject * obj1 = 0 ;
25102 PyObject * obj2 = 0 ;
25103 PyObject * obj3 = 0 ;
25104 PyObject * obj4 = 0 ;
25105 PyObject * obj5 = 0 ;
25106 PyObject * obj6 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25115 if (SWIG_arg_fail(2)) SWIG_fail;
25116 if (obj2) {
25117 {
25118 arg3 = (int const)(SWIG_As_int(obj2));
25119 if (SWIG_arg_fail(3)) SWIG_fail;
25120 }
25121 }
25122 if (obj3) {
25123 {
25124 arg4 = &temp4;
25125 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25126 }
25127 }
25128 if (obj4) {
25129 {
25130 arg5 = &temp5;
25131 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25132 }
25133 }
25134 if (obj5) {
25135 {
25136 arg6 = (long)(SWIG_As_long(obj5));
25137 if (SWIG_arg_fail(6)) SWIG_fail;
25138 }
25139 }
25140 if (obj6) {
25141 {
25142 arg7 = wxString_in_helper(obj6);
25143 if (arg7 == NULL) SWIG_fail;
25144 temp7 = true;
25145 }
25146 }
25147 {
25148 PyThreadState* __tstate = wxPyBeginAllowThreads();
25149 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25150
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 {
25155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25156 }
25157 {
25158 if (temp7)
25159 delete arg7;
25160 }
25161 return resultobj;
25162 fail:
25163 {
25164 if (temp7)
25165 delete arg7;
25166 }
25167 return NULL;
25168 }
25169
25170
25171 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25172 PyObject *resultobj;
25173 wxWindow *arg1 = (wxWindow *) 0 ;
25174 bool arg2 = (bool) false ;
25175 bool result;
25176 PyObject * obj0 = 0 ;
25177 PyObject * obj1 = 0 ;
25178 char *kwnames[] = {
25179 (char *) "self",(char *) "force", NULL
25180 };
25181
25182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25184 if (SWIG_arg_fail(1)) SWIG_fail;
25185 if (obj1) {
25186 {
25187 arg2 = (bool)(SWIG_As_bool(obj1));
25188 if (SWIG_arg_fail(2)) SWIG_fail;
25189 }
25190 }
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (bool)(arg1)->Close(arg2);
25194
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 {
25199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25200 }
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj;
25209 wxWindow *arg1 = (wxWindow *) 0 ;
25210 bool result;
25211 PyObject * obj0 = 0 ;
25212 char *kwnames[] = {
25213 (char *) "self", NULL
25214 };
25215
25216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25218 if (SWIG_arg_fail(1)) SWIG_fail;
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (bool)(arg1)->Destroy();
25222
25223 wxPyEndAllowThreads(__tstate);
25224 if (PyErr_Occurred()) SWIG_fail;
25225 }
25226 {
25227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25228 }
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj;
25237 wxWindow *arg1 = (wxWindow *) 0 ;
25238 bool result;
25239 PyObject * obj0 = 0 ;
25240 char *kwnames[] = {
25241 (char *) "self", NULL
25242 };
25243
25244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25246 if (SWIG_arg_fail(1)) SWIG_fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (bool)(arg1)->DestroyChildren();
25250
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 {
25255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj;
25265 wxWindow *arg1 = (wxWindow *) 0 ;
25266 bool result;
25267 PyObject * obj0 = 0 ;
25268 char *kwnames[] = {
25269 (char *) "self", NULL
25270 };
25271
25272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25274 if (SWIG_arg_fail(1)) SWIG_fail;
25275 {
25276 PyThreadState* __tstate = wxPyBeginAllowThreads();
25277 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25278
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 {
25283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25284 }
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25292 PyObject *resultobj;
25293 wxWindow *arg1 = (wxWindow *) 0 ;
25294 wxString *arg2 = 0 ;
25295 bool temp2 = false ;
25296 PyObject * obj0 = 0 ;
25297 PyObject * obj1 = 0 ;
25298 char *kwnames[] = {
25299 (char *) "self",(char *) "title", NULL
25300 };
25301
25302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25304 if (SWIG_arg_fail(1)) SWIG_fail;
25305 {
25306 arg2 = wxString_in_helper(obj1);
25307 if (arg2 == NULL) SWIG_fail;
25308 temp2 = true;
25309 }
25310 {
25311 PyThreadState* __tstate = wxPyBeginAllowThreads();
25312 (arg1)->SetTitle((wxString const &)*arg2);
25313
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 Py_INCREF(Py_None); resultobj = Py_None;
25318 {
25319 if (temp2)
25320 delete arg2;
25321 }
25322 return resultobj;
25323 fail:
25324 {
25325 if (temp2)
25326 delete arg2;
25327 }
25328 return NULL;
25329 }
25330
25331
25332 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25333 PyObject *resultobj;
25334 wxWindow *arg1 = (wxWindow *) 0 ;
25335 wxString result;
25336 PyObject * obj0 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "self", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25343 if (SWIG_arg_fail(1)) SWIG_fail;
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = ((wxWindow const *)arg1)->GetTitle();
25347
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 {
25352 #if wxUSE_UNICODE
25353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25354 #else
25355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25356 #endif
25357 }
25358 return resultobj;
25359 fail:
25360 return NULL;
25361 }
25362
25363
25364 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj;
25366 wxWindow *arg1 = (wxWindow *) 0 ;
25367 wxString *arg2 = 0 ;
25368 bool temp2 = false ;
25369 PyObject * obj0 = 0 ;
25370 PyObject * obj1 = 0 ;
25371 char *kwnames[] = {
25372 (char *) "self",(char *) "label", NULL
25373 };
25374
25375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25377 if (SWIG_arg_fail(1)) SWIG_fail;
25378 {
25379 arg2 = wxString_in_helper(obj1);
25380 if (arg2 == NULL) SWIG_fail;
25381 temp2 = true;
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 (arg1)->SetLabel((wxString const &)*arg2);
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 Py_INCREF(Py_None); resultobj = Py_None;
25391 {
25392 if (temp2)
25393 delete arg2;
25394 }
25395 return resultobj;
25396 fail:
25397 {
25398 if (temp2)
25399 delete arg2;
25400 }
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 wxWindow *arg1 = (wxWindow *) 0 ;
25408 wxString result;
25409 PyObject * obj0 = 0 ;
25410 char *kwnames[] = {
25411 (char *) "self", NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25416 if (SWIG_arg_fail(1)) SWIG_fail;
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = ((wxWindow const *)arg1)->GetLabel();
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 {
25425 #if wxUSE_UNICODE
25426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25427 #else
25428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25429 #endif
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj;
25439 wxWindow *arg1 = (wxWindow *) 0 ;
25440 wxString *arg2 = 0 ;
25441 bool temp2 = false ;
25442 PyObject * obj0 = 0 ;
25443 PyObject * obj1 = 0 ;
25444 char *kwnames[] = {
25445 (char *) "self",(char *) "name", NULL
25446 };
25447
25448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25450 if (SWIG_arg_fail(1)) SWIG_fail;
25451 {
25452 arg2 = wxString_in_helper(obj1);
25453 if (arg2 == NULL) SWIG_fail;
25454 temp2 = true;
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 (arg1)->SetName((wxString const &)*arg2);
25459
25460 wxPyEndAllowThreads(__tstate);
25461 if (PyErr_Occurred()) SWIG_fail;
25462 }
25463 Py_INCREF(Py_None); resultobj = Py_None;
25464 {
25465 if (temp2)
25466 delete arg2;
25467 }
25468 return resultobj;
25469 fail:
25470 {
25471 if (temp2)
25472 delete arg2;
25473 }
25474 return NULL;
25475 }
25476
25477
25478 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25479 PyObject *resultobj;
25480 wxWindow *arg1 = (wxWindow *) 0 ;
25481 wxString result;
25482 PyObject * obj0 = 0 ;
25483 char *kwnames[] = {
25484 (char *) "self", NULL
25485 };
25486
25487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25489 if (SWIG_arg_fail(1)) SWIG_fail;
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = ((wxWindow const *)arg1)->GetName();
25493
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 #if wxUSE_UNICODE
25499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25500 #else
25501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25502 #endif
25503 }
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25511 PyObject *resultobj;
25512 wxWindow *arg1 = (wxWindow *) 0 ;
25513 wxWindowVariant arg2 ;
25514 PyObject * obj0 = 0 ;
25515 PyObject * obj1 = 0 ;
25516 char *kwnames[] = {
25517 (char *) "self",(char *) "variant", NULL
25518 };
25519
25520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25522 if (SWIG_arg_fail(1)) SWIG_fail;
25523 {
25524 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25525 if (SWIG_arg_fail(2)) SWIG_fail;
25526 }
25527 {
25528 PyThreadState* __tstate = wxPyBeginAllowThreads();
25529 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25530
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 Py_INCREF(Py_None); resultobj = Py_None;
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj;
25543 wxWindow *arg1 = (wxWindow *) 0 ;
25544 wxWindowVariant result;
25545 PyObject * obj0 = 0 ;
25546 char *kwnames[] = {
25547 (char *) "self", NULL
25548 };
25549
25550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25552 if (SWIG_arg_fail(1)) SWIG_fail;
25553 {
25554 PyThreadState* __tstate = wxPyBeginAllowThreads();
25555 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25556
25557 wxPyEndAllowThreads(__tstate);
25558 if (PyErr_Occurred()) SWIG_fail;
25559 }
25560 resultobj = SWIG_From_int((result));
25561 return resultobj;
25562 fail:
25563 return NULL;
25564 }
25565
25566
25567 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj;
25569 wxWindow *arg1 = (wxWindow *) 0 ;
25570 int arg2 ;
25571 PyObject * obj0 = 0 ;
25572 PyObject * obj1 = 0 ;
25573 char *kwnames[] = {
25574 (char *) "self",(char *) "winid", NULL
25575 };
25576
25577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25579 if (SWIG_arg_fail(1)) SWIG_fail;
25580 {
25581 arg2 = (int)(SWIG_As_int(obj1));
25582 if (SWIG_arg_fail(2)) SWIG_fail;
25583 }
25584 {
25585 PyThreadState* __tstate = wxPyBeginAllowThreads();
25586 (arg1)->SetId(arg2);
25587
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 Py_INCREF(Py_None); resultobj = Py_None;
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj;
25600 wxWindow *arg1 = (wxWindow *) 0 ;
25601 int result;
25602 PyObject * obj0 = 0 ;
25603 char *kwnames[] = {
25604 (char *) "self", NULL
25605 };
25606
25607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25609 if (SWIG_arg_fail(1)) SWIG_fail;
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 result = (int)((wxWindow const *)arg1)->GetId();
25613
25614 wxPyEndAllowThreads(__tstate);
25615 if (PyErr_Occurred()) SWIG_fail;
25616 }
25617 {
25618 resultobj = SWIG_From_int((int)(result));
25619 }
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25627 PyObject *resultobj;
25628 int result;
25629 char *kwnames[] = {
25630 NULL
25631 };
25632
25633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (int)wxWindow::NewControlId();
25637
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 {
25642 resultobj = SWIG_From_int((int)(result));
25643 }
25644 return resultobj;
25645 fail:
25646 return NULL;
25647 }
25648
25649
25650 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25651 PyObject *resultobj;
25652 int arg1 ;
25653 int result;
25654 PyObject * obj0 = 0 ;
25655 char *kwnames[] = {
25656 (char *) "winid", NULL
25657 };
25658
25659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25660 {
25661 arg1 = (int)(SWIG_As_int(obj0));
25662 if (SWIG_arg_fail(1)) SWIG_fail;
25663 }
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (int)wxWindow::NextControlId(arg1);
25667
25668 wxPyEndAllowThreads(__tstate);
25669 if (PyErr_Occurred()) SWIG_fail;
25670 }
25671 {
25672 resultobj = SWIG_From_int((int)(result));
25673 }
25674 return resultobj;
25675 fail:
25676 return NULL;
25677 }
25678
25679
25680 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25681 PyObject *resultobj;
25682 int arg1 ;
25683 int result;
25684 PyObject * obj0 = 0 ;
25685 char *kwnames[] = {
25686 (char *) "winid", NULL
25687 };
25688
25689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25690 {
25691 arg1 = (int)(SWIG_As_int(obj0));
25692 if (SWIG_arg_fail(1)) SWIG_fail;
25693 }
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 result = (int)wxWindow::PrevControlId(arg1);
25697
25698 wxPyEndAllowThreads(__tstate);
25699 if (PyErr_Occurred()) SWIG_fail;
25700 }
25701 {
25702 resultobj = SWIG_From_int((int)(result));
25703 }
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxWindow *arg1 = (wxWindow *) 0 ;
25713 wxSize *arg2 = 0 ;
25714 wxSize temp2 ;
25715 PyObject * obj0 = 0 ;
25716 PyObject * obj1 = 0 ;
25717 char *kwnames[] = {
25718 (char *) "self",(char *) "size", NULL
25719 };
25720
25721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25723 if (SWIG_arg_fail(1)) SWIG_fail;
25724 {
25725 arg2 = &temp2;
25726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 (arg1)->SetSize((wxSize const &)*arg2);
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 Py_INCREF(Py_None); resultobj = Py_None;
25736 return resultobj;
25737 fail:
25738 return NULL;
25739 }
25740
25741
25742 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25743 PyObject *resultobj;
25744 wxWindow *arg1 = (wxWindow *) 0 ;
25745 int arg2 ;
25746 int arg3 ;
25747 int arg4 ;
25748 int arg5 ;
25749 int arg6 = (int) wxSIZE_AUTO ;
25750 PyObject * obj0 = 0 ;
25751 PyObject * obj1 = 0 ;
25752 PyObject * obj2 = 0 ;
25753 PyObject * obj3 = 0 ;
25754 PyObject * obj4 = 0 ;
25755 PyObject * obj5 = 0 ;
25756 char *kwnames[] = {
25757 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25758 };
25759
25760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25762 if (SWIG_arg_fail(1)) SWIG_fail;
25763 {
25764 arg2 = (int)(SWIG_As_int(obj1));
25765 if (SWIG_arg_fail(2)) SWIG_fail;
25766 }
25767 {
25768 arg3 = (int)(SWIG_As_int(obj2));
25769 if (SWIG_arg_fail(3)) SWIG_fail;
25770 }
25771 {
25772 arg4 = (int)(SWIG_As_int(obj3));
25773 if (SWIG_arg_fail(4)) SWIG_fail;
25774 }
25775 {
25776 arg5 = (int)(SWIG_As_int(obj4));
25777 if (SWIG_arg_fail(5)) SWIG_fail;
25778 }
25779 if (obj5) {
25780 {
25781 arg6 = (int)(SWIG_As_int(obj5));
25782 if (SWIG_arg_fail(6)) SWIG_fail;
25783 }
25784 }
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 Py_INCREF(Py_None); resultobj = Py_None;
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj;
25801 wxWindow *arg1 = (wxWindow *) 0 ;
25802 wxRect *arg2 = 0 ;
25803 int arg3 = (int) wxSIZE_AUTO ;
25804 wxRect temp2 ;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 PyObject * obj2 = 0 ;
25808 char *kwnames[] = {
25809 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25810 };
25811
25812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25814 if (SWIG_arg_fail(1)) SWIG_fail;
25815 {
25816 arg2 = &temp2;
25817 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25818 }
25819 if (obj2) {
25820 {
25821 arg3 = (int)(SWIG_As_int(obj2));
25822 if (SWIG_arg_fail(3)) SWIG_fail;
25823 }
25824 }
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 Py_INCREF(Py_None); resultobj = Py_None;
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj;
25841 wxWindow *arg1 = (wxWindow *) 0 ;
25842 int arg2 ;
25843 int arg3 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 PyObject * obj2 = 0 ;
25847 char *kwnames[] = {
25848 (char *) "self",(char *) "width",(char *) "height", NULL
25849 };
25850
25851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25853 if (SWIG_arg_fail(1)) SWIG_fail;
25854 {
25855 arg2 = (int)(SWIG_As_int(obj1));
25856 if (SWIG_arg_fail(2)) SWIG_fail;
25857 }
25858 {
25859 arg3 = (int)(SWIG_As_int(obj2));
25860 if (SWIG_arg_fail(3)) SWIG_fail;
25861 }
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 (arg1)->SetSize(arg2,arg3);
25865
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 Py_INCREF(Py_None); resultobj = Py_None;
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj;
25878 wxWindow *arg1 = (wxWindow *) 0 ;
25879 wxPoint *arg2 = 0 ;
25880 int arg3 = (int) wxSIZE_USE_EXISTING ;
25881 wxPoint temp2 ;
25882 PyObject * obj0 = 0 ;
25883 PyObject * obj1 = 0 ;
25884 PyObject * obj2 = 0 ;
25885 char *kwnames[] = {
25886 (char *) "self",(char *) "pt",(char *) "flags", NULL
25887 };
25888
25889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25891 if (SWIG_arg_fail(1)) SWIG_fail;
25892 {
25893 arg2 = &temp2;
25894 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25895 }
25896 if (obj2) {
25897 {
25898 arg3 = (int)(SWIG_As_int(obj2));
25899 if (SWIG_arg_fail(3)) SWIG_fail;
25900 }
25901 }
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 (arg1)->Move((wxPoint const &)*arg2,arg3);
25905
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 Py_INCREF(Py_None); resultobj = Py_None;
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj;
25918 wxWindow *arg1 = (wxWindow *) 0 ;
25919 int arg2 ;
25920 int arg3 ;
25921 int arg4 = (int) wxSIZE_USE_EXISTING ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 PyObject * obj2 = 0 ;
25925 PyObject * obj3 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 {
25934 arg2 = (int)(SWIG_As_int(obj1));
25935 if (SWIG_arg_fail(2)) SWIG_fail;
25936 }
25937 {
25938 arg3 = (int)(SWIG_As_int(obj2));
25939 if (SWIG_arg_fail(3)) SWIG_fail;
25940 }
25941 if (obj3) {
25942 {
25943 arg4 = (int)(SWIG_As_int(obj3));
25944 if (SWIG_arg_fail(4)) SWIG_fail;
25945 }
25946 }
25947 {
25948 PyThreadState* __tstate = wxPyBeginAllowThreads();
25949 (arg1)->Move(arg2,arg3,arg4);
25950
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 Py_INCREF(Py_None); resultobj = Py_None;
25955 return resultobj;
25956 fail:
25957 return NULL;
25958 }
25959
25960
25961 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj;
25963 wxWindow *arg1 = (wxWindow *) 0 ;
25964 wxSize const &arg2_defvalue = wxDefaultSize ;
25965 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25966 wxSize temp2 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char *kwnames[] = {
25970 (char *) "self",(char *) "size", NULL
25971 };
25972
25973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25975 if (SWIG_arg_fail(1)) SWIG_fail;
25976 if (obj1) {
25977 {
25978 arg2 = &temp2;
25979 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25980 }
25981 }
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25985
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 Py_INCREF(Py_None); resultobj = Py_None;
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25997 PyObject *resultobj;
25998 wxWindow *arg1 = (wxWindow *) 0 ;
25999 PyObject * obj0 = 0 ;
26000 char *kwnames[] = {
26001 (char *) "self", NULL
26002 };
26003
26004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26006 if (SWIG_arg_fail(1)) SWIG_fail;
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 (arg1)->Raise();
26010
26011 wxPyEndAllowThreads(__tstate);
26012 if (PyErr_Occurred()) SWIG_fail;
26013 }
26014 Py_INCREF(Py_None); resultobj = Py_None;
26015 return resultobj;
26016 fail:
26017 return NULL;
26018 }
26019
26020
26021 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26022 PyObject *resultobj;
26023 wxWindow *arg1 = (wxWindow *) 0 ;
26024 PyObject * obj0 = 0 ;
26025 char *kwnames[] = {
26026 (char *) "self", NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26031 if (SWIG_arg_fail(1)) SWIG_fail;
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 (arg1)->Lower();
26035
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 Py_INCREF(Py_None); resultobj = Py_None;
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj;
26048 wxWindow *arg1 = (wxWindow *) 0 ;
26049 wxSize *arg2 = 0 ;
26050 wxSize temp2 ;
26051 PyObject * obj0 = 0 ;
26052 PyObject * obj1 = 0 ;
26053 char *kwnames[] = {
26054 (char *) "self",(char *) "size", NULL
26055 };
26056
26057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26059 if (SWIG_arg_fail(1)) SWIG_fail;
26060 {
26061 arg2 = &temp2;
26062 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26063 }
26064 {
26065 PyThreadState* __tstate = wxPyBeginAllowThreads();
26066 (arg1)->SetClientSize((wxSize const &)*arg2);
26067
26068 wxPyEndAllowThreads(__tstate);
26069 if (PyErr_Occurred()) SWIG_fail;
26070 }
26071 Py_INCREF(Py_None); resultobj = Py_None;
26072 return resultobj;
26073 fail:
26074 return NULL;
26075 }
26076
26077
26078 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26079 PyObject *resultobj;
26080 wxWindow *arg1 = (wxWindow *) 0 ;
26081 int arg2 ;
26082 int arg3 ;
26083 PyObject * obj0 = 0 ;
26084 PyObject * obj1 = 0 ;
26085 PyObject * obj2 = 0 ;
26086 char *kwnames[] = {
26087 (char *) "self",(char *) "width",(char *) "height", NULL
26088 };
26089
26090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26092 if (SWIG_arg_fail(1)) SWIG_fail;
26093 {
26094 arg2 = (int)(SWIG_As_int(obj1));
26095 if (SWIG_arg_fail(2)) SWIG_fail;
26096 }
26097 {
26098 arg3 = (int)(SWIG_As_int(obj2));
26099 if (SWIG_arg_fail(3)) SWIG_fail;
26100 }
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 (arg1)->SetClientSize(arg2,arg3);
26104
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 Py_INCREF(Py_None); resultobj = Py_None;
26109 return resultobj;
26110 fail:
26111 return NULL;
26112 }
26113
26114
26115 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26116 PyObject *resultobj;
26117 wxWindow *arg1 = (wxWindow *) 0 ;
26118 wxRect *arg2 = 0 ;
26119 wxRect temp2 ;
26120 PyObject * obj0 = 0 ;
26121 PyObject * obj1 = 0 ;
26122 char *kwnames[] = {
26123 (char *) "self",(char *) "rect", NULL
26124 };
26125
26126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26128 if (SWIG_arg_fail(1)) SWIG_fail;
26129 {
26130 arg2 = &temp2;
26131 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetClientSize((wxRect const &)*arg2);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxPoint result;
26151 PyObject * obj0 = 0 ;
26152 char *kwnames[] = {
26153 (char *) "self", NULL
26154 };
26155
26156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26158 if (SWIG_arg_fail(1)) SWIG_fail;
26159 {
26160 PyThreadState* __tstate = wxPyBeginAllowThreads();
26161 result = (arg1)->GetPosition();
26162
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 {
26167 wxPoint * resultptr;
26168 resultptr = new wxPoint((wxPoint &)(result));
26169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26170 }
26171 return resultobj;
26172 fail:
26173 return NULL;
26174 }
26175
26176
26177 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26178 PyObject *resultobj;
26179 wxWindow *arg1 = (wxWindow *) 0 ;
26180 int *arg2 = (int *) 0 ;
26181 int *arg3 = (int *) 0 ;
26182 int temp2 ;
26183 int res2 = 0 ;
26184 int temp3 ;
26185 int res3 = 0 ;
26186 PyObject * obj0 = 0 ;
26187 char *kwnames[] = {
26188 (char *) "self", NULL
26189 };
26190
26191 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26192 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26195 if (SWIG_arg_fail(1)) SWIG_fail;
26196 {
26197 PyThreadState* __tstate = wxPyBeginAllowThreads();
26198 (arg1)->GetPosition(arg2,arg3);
26199
26200 wxPyEndAllowThreads(__tstate);
26201 if (PyErr_Occurred()) SWIG_fail;
26202 }
26203 Py_INCREF(Py_None); resultobj = Py_None;
26204 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26205 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26206 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26207 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26208 return resultobj;
26209 fail:
26210 return NULL;
26211 }
26212
26213
26214 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26215 PyObject *resultobj;
26216 wxWindow *arg1 = (wxWindow *) 0 ;
26217 wxSize result;
26218 PyObject * obj0 = 0 ;
26219 char *kwnames[] = {
26220 (char *) "self", NULL
26221 };
26222
26223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26225 if (SWIG_arg_fail(1)) SWIG_fail;
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 result = ((wxWindow const *)arg1)->GetSize();
26229
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 wxSize * resultptr;
26235 resultptr = new wxSize((wxSize &)(result));
26236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26237 }
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj;
26246 wxWindow *arg1 = (wxWindow *) 0 ;
26247 int *arg2 = (int *) 0 ;
26248 int *arg3 = (int *) 0 ;
26249 int temp2 ;
26250 int res2 = 0 ;
26251 int temp3 ;
26252 int res3 = 0 ;
26253 PyObject * obj0 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self", NULL
26256 };
26257
26258 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26259 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26266
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 Py_INCREF(Py_None); resultobj = Py_None;
26271 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26272 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26273 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26274 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj;
26283 wxWindow *arg1 = (wxWindow *) 0 ;
26284 wxRect result;
26285 PyObject * obj0 = 0 ;
26286 char *kwnames[] = {
26287 (char *) "self", NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26292 if (SWIG_arg_fail(1)) SWIG_fail;
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = ((wxWindow const *)arg1)->GetRect();
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 wxRect * resultptr;
26302 resultptr = new wxRect((wxRect &)(result));
26303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26312 PyObject *resultobj;
26313 wxWindow *arg1 = (wxWindow *) 0 ;
26314 wxSize result;
26315 PyObject * obj0 = 0 ;
26316 char *kwnames[] = {
26317 (char *) "self", NULL
26318 };
26319
26320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26322 if (SWIG_arg_fail(1)) SWIG_fail;
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = ((wxWindow const *)arg1)->GetClientSize();
26326
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 {
26331 wxSize * resultptr;
26332 resultptr = new wxSize((wxSize &)(result));
26333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26334 }
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj;
26343 wxWindow *arg1 = (wxWindow *) 0 ;
26344 int *arg2 = (int *) 0 ;
26345 int *arg3 = (int *) 0 ;
26346 int temp2 ;
26347 int res2 = 0 ;
26348 int temp3 ;
26349 int res3 = 0 ;
26350 PyObject * obj0 = 0 ;
26351 char *kwnames[] = {
26352 (char *) "self", NULL
26353 };
26354
26355 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26356 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26359 if (SWIG_arg_fail(1)) SWIG_fail;
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26363
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 Py_INCREF(Py_None); resultobj = Py_None;
26368 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26369 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26379 PyObject *resultobj;
26380 wxWindow *arg1 = (wxWindow *) 0 ;
26381 wxPoint result;
26382 PyObject * obj0 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 {
26398 wxPoint * resultptr;
26399 resultptr = new wxPoint((wxPoint &)(result));
26400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26401 }
26402 return resultobj;
26403 fail:
26404 return NULL;
26405 }
26406
26407
26408 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj;
26410 wxWindow *arg1 = (wxWindow *) 0 ;
26411 wxRect result;
26412 PyObject * obj0 = 0 ;
26413 char *kwnames[] = {
26414 (char *) "self", NULL
26415 };
26416
26417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26419 if (SWIG_arg_fail(1)) SWIG_fail;
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = ((wxWindow const *)arg1)->GetClientRect();
26423
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 {
26428 wxRect * resultptr;
26429 resultptr = new wxRect((wxRect &)(result));
26430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26431 }
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26439 PyObject *resultobj;
26440 wxWindow *arg1 = (wxWindow *) 0 ;
26441 wxSize result;
26442 PyObject * obj0 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = ((wxWindow const *)arg1)->GetBestSize();
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 {
26458 wxSize * resultptr;
26459 resultptr = new wxSize((wxSize &)(result));
26460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj;
26470 wxWindow *arg1 = (wxWindow *) 0 ;
26471 int *arg2 = (int *) 0 ;
26472 int *arg3 = (int *) 0 ;
26473 int temp2 ;
26474 int res2 = 0 ;
26475 int temp3 ;
26476 int res3 = 0 ;
26477 PyObject * obj0 = 0 ;
26478 char *kwnames[] = {
26479 (char *) "self", NULL
26480 };
26481
26482 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26483 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26486 if (SWIG_arg_fail(1)) SWIG_fail;
26487 {
26488 PyThreadState* __tstate = wxPyBeginAllowThreads();
26489 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26490
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 Py_INCREF(Py_None); resultobj = Py_None;
26495 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26496 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26497 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26498 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj;
26507 wxWindow *arg1 = (wxWindow *) 0 ;
26508 PyObject * obj0 = 0 ;
26509 char *kwnames[] = {
26510 (char *) "self", NULL
26511 };
26512
26513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 (arg1)->InvalidateBestSize();
26519
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 Py_INCREF(Py_None); resultobj = Py_None;
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj;
26532 wxWindow *arg1 = (wxWindow *) 0 ;
26533 wxSize result;
26534 PyObject * obj0 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "self", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(1)) SWIG_fail;
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26545
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 {
26550 wxSize * resultptr;
26551 resultptr = new wxSize((wxSize &)(result));
26552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26553 }
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj;
26562 wxWindow *arg1 = (wxWindow *) 0 ;
26563 wxSize result;
26564 PyObject * obj0 = 0 ;
26565 char *kwnames[] = {
26566 (char *) "self", NULL
26567 };
26568
26569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(1)) SWIG_fail;
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26575
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 {
26580 wxSize * resultptr;
26581 resultptr = new wxSize((wxSize &)(result));
26582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26583 }
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj;
26592 wxWindow *arg1 = (wxWindow *) 0 ;
26593 int arg2 = (int) wxBOTH ;
26594 PyObject * obj0 = 0 ;
26595 PyObject * obj1 = 0 ;
26596 char *kwnames[] = {
26597 (char *) "self",(char *) "direction", NULL
26598 };
26599
26600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26602 if (SWIG_arg_fail(1)) SWIG_fail;
26603 if (obj1) {
26604 {
26605 arg2 = (int)(SWIG_As_int(obj1));
26606 if (SWIG_arg_fail(2)) SWIG_fail;
26607 }
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->Center(arg2);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 Py_INCREF(Py_None); resultobj = Py_None;
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 int arg2 = (int) wxBOTH ;
26627 PyObject * obj0 = 0 ;
26628 PyObject * obj1 = 0 ;
26629 char *kwnames[] = {
26630 (char *) "self",(char *) "dir", NULL
26631 };
26632
26633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26635 if (SWIG_arg_fail(1)) SWIG_fail;
26636 if (obj1) {
26637 {
26638 arg2 = (int)(SWIG_As_int(obj1));
26639 if (SWIG_arg_fail(2)) SWIG_fail;
26640 }
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->CenterOnScreen(arg2);
26645
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 Py_INCREF(Py_None); resultobj = Py_None;
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj;
26658 wxWindow *arg1 = (wxWindow *) 0 ;
26659 int arg2 = (int) wxBOTH ;
26660 PyObject * obj0 = 0 ;
26661 PyObject * obj1 = 0 ;
26662 char *kwnames[] = {
26663 (char *) "self",(char *) "dir", NULL
26664 };
26665
26666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(1)) SWIG_fail;
26669 if (obj1) {
26670 {
26671 arg2 = (int)(SWIG_As_int(obj1));
26672 if (SWIG_arg_fail(2)) SWIG_fail;
26673 }
26674 }
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 (arg1)->CenterOnParent(arg2);
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 Py_INCREF(Py_None); resultobj = Py_None;
26683 return resultobj;
26684 fail:
26685 return NULL;
26686 }
26687
26688
26689 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj;
26691 wxWindow *arg1 = (wxWindow *) 0 ;
26692 PyObject * obj0 = 0 ;
26693 char *kwnames[] = {
26694 (char *) "self", NULL
26695 };
26696
26697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26699 if (SWIG_arg_fail(1)) SWIG_fail;
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 (arg1)->Fit();
26703
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 Py_INCREF(Py_None); resultobj = Py_None;
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26715 PyObject *resultobj;
26716 wxWindow *arg1 = (wxWindow *) 0 ;
26717 PyObject * obj0 = 0 ;
26718 char *kwnames[] = {
26719 (char *) "self", NULL
26720 };
26721
26722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26724 if (SWIG_arg_fail(1)) SWIG_fail;
26725 {
26726 PyThreadState* __tstate = wxPyBeginAllowThreads();
26727 (arg1)->FitInside();
26728
26729 wxPyEndAllowThreads(__tstate);
26730 if (PyErr_Occurred()) SWIG_fail;
26731 }
26732 Py_INCREF(Py_None); resultobj = Py_None;
26733 return resultobj;
26734 fail:
26735 return NULL;
26736 }
26737
26738
26739 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj;
26741 wxWindow *arg1 = (wxWindow *) 0 ;
26742 int arg2 ;
26743 int arg3 ;
26744 int arg4 = (int) -1 ;
26745 int arg5 = (int) -1 ;
26746 int arg6 = (int) -1 ;
26747 int arg7 = (int) -1 ;
26748 PyObject * obj0 = 0 ;
26749 PyObject * obj1 = 0 ;
26750 PyObject * obj2 = 0 ;
26751 PyObject * obj3 = 0 ;
26752 PyObject * obj4 = 0 ;
26753 PyObject * obj5 = 0 ;
26754 PyObject * obj6 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(1)) SWIG_fail;
26762 {
26763 arg2 = (int)(SWIG_As_int(obj1));
26764 if (SWIG_arg_fail(2)) SWIG_fail;
26765 }
26766 {
26767 arg3 = (int)(SWIG_As_int(obj2));
26768 if (SWIG_arg_fail(3)) SWIG_fail;
26769 }
26770 if (obj3) {
26771 {
26772 arg4 = (int)(SWIG_As_int(obj3));
26773 if (SWIG_arg_fail(4)) SWIG_fail;
26774 }
26775 }
26776 if (obj4) {
26777 {
26778 arg5 = (int)(SWIG_As_int(obj4));
26779 if (SWIG_arg_fail(5)) SWIG_fail;
26780 }
26781 }
26782 if (obj5) {
26783 {
26784 arg6 = (int)(SWIG_As_int(obj5));
26785 if (SWIG_arg_fail(6)) SWIG_fail;
26786 }
26787 }
26788 if (obj6) {
26789 {
26790 arg7 = (int)(SWIG_As_int(obj6));
26791 if (SWIG_arg_fail(7)) SWIG_fail;
26792 }
26793 }
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26797
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 Py_INCREF(Py_None); resultobj = Py_None;
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj;
26810 wxWindow *arg1 = (wxWindow *) 0 ;
26811 wxSize *arg2 = 0 ;
26812 wxSize const &arg3_defvalue = wxDefaultSize ;
26813 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26814 wxSize const &arg4_defvalue = wxDefaultSize ;
26815 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26816 wxSize temp2 ;
26817 wxSize temp3 ;
26818 wxSize temp4 ;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821 PyObject * obj2 = 0 ;
26822 PyObject * obj3 = 0 ;
26823 char *kwnames[] = {
26824 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26825 };
26826
26827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26829 if (SWIG_arg_fail(1)) SWIG_fail;
26830 {
26831 arg2 = &temp2;
26832 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26833 }
26834 if (obj2) {
26835 {
26836 arg3 = &temp3;
26837 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26838 }
26839 }
26840 if (obj3) {
26841 {
26842 arg4 = &temp4;
26843 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26844 }
26845 }
26846 {
26847 PyThreadState* __tstate = wxPyBeginAllowThreads();
26848 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26849
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 Py_INCREF(Py_None); resultobj = Py_None;
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj;
26862 wxWindow *arg1 = (wxWindow *) 0 ;
26863 int arg2 ;
26864 int arg3 ;
26865 int arg4 = (int) -1 ;
26866 int arg5 = (int) -1 ;
26867 PyObject * obj0 = 0 ;
26868 PyObject * obj1 = 0 ;
26869 PyObject * obj2 = 0 ;
26870 PyObject * obj3 = 0 ;
26871 PyObject * obj4 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26874 };
26875
26876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 {
26880 arg2 = (int)(SWIG_As_int(obj1));
26881 if (SWIG_arg_fail(2)) SWIG_fail;
26882 }
26883 {
26884 arg3 = (int)(SWIG_As_int(obj2));
26885 if (SWIG_arg_fail(3)) SWIG_fail;
26886 }
26887 if (obj3) {
26888 {
26889 arg4 = (int)(SWIG_As_int(obj3));
26890 if (SWIG_arg_fail(4)) SWIG_fail;
26891 }
26892 }
26893 if (obj4) {
26894 {
26895 arg5 = (int)(SWIG_As_int(obj4));
26896 if (SWIG_arg_fail(5)) SWIG_fail;
26897 }
26898 }
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 Py_INCREF(Py_None); resultobj = Py_None;
26907 return resultobj;
26908 fail:
26909 return NULL;
26910 }
26911
26912
26913 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26914 PyObject *resultobj;
26915 wxWindow *arg1 = (wxWindow *) 0 ;
26916 wxSize *arg2 = 0 ;
26917 wxSize const &arg3_defvalue = wxDefaultSize ;
26918 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26919 wxSize temp2 ;
26920 wxSize temp3 ;
26921 PyObject * obj0 = 0 ;
26922 PyObject * obj1 = 0 ;
26923 PyObject * obj2 = 0 ;
26924 char *kwnames[] = {
26925 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26926 };
26927
26928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26930 if (SWIG_arg_fail(1)) SWIG_fail;
26931 {
26932 arg2 = &temp2;
26933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26934 }
26935 if (obj2) {
26936 {
26937 arg3 = &temp3;
26938 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26939 }
26940 }
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26944
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 Py_INCREF(Py_None); resultobj = Py_None;
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj;
26957 wxWindow *arg1 = (wxWindow *) 0 ;
26958 wxSize result;
26959 PyObject * obj0 = 0 ;
26960 char *kwnames[] = {
26961 (char *) "self", NULL
26962 };
26963
26964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26966 if (SWIG_arg_fail(1)) SWIG_fail;
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 result = ((wxWindow const *)arg1)->GetMaxSize();
26970
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 {
26975 wxSize * resultptr;
26976 resultptr = new wxSize((wxSize &)(result));
26977 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26978 }
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26986 PyObject *resultobj;
26987 wxWindow *arg1 = (wxWindow *) 0 ;
26988 wxSize result;
26989 PyObject * obj0 = 0 ;
26990 char *kwnames[] = {
26991 (char *) "self", NULL
26992 };
26993
26994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26996 if (SWIG_arg_fail(1)) SWIG_fail;
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 result = ((wxWindow const *)arg1)->GetMinSize();
27000
27001 wxPyEndAllowThreads(__tstate);
27002 if (PyErr_Occurred()) SWIG_fail;
27003 }
27004 {
27005 wxSize * resultptr;
27006 resultptr = new wxSize((wxSize &)(result));
27007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27008 }
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27016 PyObject *resultobj;
27017 wxWindow *arg1 = (wxWindow *) 0 ;
27018 wxSize *arg2 = 0 ;
27019 wxSize temp2 ;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 char *kwnames[] = {
27023 (char *) "self",(char *) "minSize", NULL
27024 };
27025
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 {
27030 arg2 = &temp2;
27031 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27032 }
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 (arg1)->SetMinSize((wxSize const &)*arg2);
27036
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 Py_INCREF(Py_None); resultobj = Py_None;
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 wxSize *arg2 = 0 ;
27051 wxSize temp2 ;
27052 PyObject * obj0 = 0 ;
27053 PyObject * obj1 = 0 ;
27054 char *kwnames[] = {
27055 (char *) "self",(char *) "maxSize", NULL
27056 };
27057
27058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27060 if (SWIG_arg_fail(1)) SWIG_fail;
27061 {
27062 arg2 = &temp2;
27063 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27064 }
27065 {
27066 PyThreadState* __tstate = wxPyBeginAllowThreads();
27067 (arg1)->SetMaxSize((wxSize const &)*arg2);
27068
27069 wxPyEndAllowThreads(__tstate);
27070 if (PyErr_Occurred()) SWIG_fail;
27071 }
27072 Py_INCREF(Py_None); resultobj = Py_None;
27073 return resultobj;
27074 fail:
27075 return NULL;
27076 }
27077
27078
27079 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27080 PyObject *resultobj;
27081 wxWindow *arg1 = (wxWindow *) 0 ;
27082 int result;
27083 PyObject * obj0 = 0 ;
27084 char *kwnames[] = {
27085 (char *) "self", NULL
27086 };
27087
27088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27090 if (SWIG_arg_fail(1)) SWIG_fail;
27091 {
27092 PyThreadState* __tstate = wxPyBeginAllowThreads();
27093 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27094
27095 wxPyEndAllowThreads(__tstate);
27096 if (PyErr_Occurred()) SWIG_fail;
27097 }
27098 {
27099 resultobj = SWIG_From_int((int)(result));
27100 }
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj;
27109 wxWindow *arg1 = (wxWindow *) 0 ;
27110 int result;
27111 PyObject * obj0 = 0 ;
27112 char *kwnames[] = {
27113 (char *) "self", NULL
27114 };
27115
27116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27118 if (SWIG_arg_fail(1)) SWIG_fail;
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27122
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 {
27127 resultobj = SWIG_From_int((int)(result));
27128 }
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27136 PyObject *resultobj;
27137 wxWindow *arg1 = (wxWindow *) 0 ;
27138 int result;
27139 PyObject * obj0 = 0 ;
27140 char *kwnames[] = {
27141 (char *) "self", NULL
27142 };
27143
27144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27146 if (SWIG_arg_fail(1)) SWIG_fail;
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27150
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 {
27155 resultobj = SWIG_From_int((int)(result));
27156 }
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27164 PyObject *resultobj;
27165 wxWindow *arg1 = (wxWindow *) 0 ;
27166 int result;
27167 PyObject * obj0 = 0 ;
27168 char *kwnames[] = {
27169 (char *) "self", NULL
27170 };
27171
27172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27174 if (SWIG_arg_fail(1)) SWIG_fail;
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27178
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 {
27183 resultobj = SWIG_From_int((int)(result));
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj;
27193 wxWindow *arg1 = (wxWindow *) 0 ;
27194 wxSize *arg2 = 0 ;
27195 wxSize temp2 ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char *kwnames[] = {
27199 (char *) "self",(char *) "size", NULL
27200 };
27201
27202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27204 if (SWIG_arg_fail(1)) SWIG_fail;
27205 {
27206 arg2 = &temp2;
27207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27208 }
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27212
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 Py_INCREF(Py_None); resultobj = Py_None;
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj;
27225 wxWindow *arg1 = (wxWindow *) 0 ;
27226 int arg2 ;
27227 int arg3 ;
27228 PyObject * obj0 = 0 ;
27229 PyObject * obj1 = 0 ;
27230 PyObject * obj2 = 0 ;
27231 char *kwnames[] = {
27232 (char *) "self",(char *) "w",(char *) "h", NULL
27233 };
27234
27235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27237 if (SWIG_arg_fail(1)) SWIG_fail;
27238 {
27239 arg2 = (int)(SWIG_As_int(obj1));
27240 if (SWIG_arg_fail(2)) SWIG_fail;
27241 }
27242 {
27243 arg3 = (int)(SWIG_As_int(obj2));
27244 if (SWIG_arg_fail(3)) SWIG_fail;
27245 }
27246 {
27247 PyThreadState* __tstate = wxPyBeginAllowThreads();
27248 (arg1)->SetVirtualSize(arg2,arg3);
27249
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 Py_INCREF(Py_None); resultobj = Py_None;
27254 return resultobj;
27255 fail:
27256 return NULL;
27257 }
27258
27259
27260 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27261 PyObject *resultobj;
27262 wxWindow *arg1 = (wxWindow *) 0 ;
27263 wxSize result;
27264 PyObject * obj0 = 0 ;
27265 char *kwnames[] = {
27266 (char *) "self", NULL
27267 };
27268
27269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 result = ((wxWindow const *)arg1)->GetVirtualSize();
27275
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 {
27280 wxSize * resultptr;
27281 resultptr = new wxSize((wxSize &)(result));
27282 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj;
27292 wxWindow *arg1 = (wxWindow *) 0 ;
27293 int *arg2 = (int *) 0 ;
27294 int *arg3 = (int *) 0 ;
27295 int temp2 ;
27296 int res2 = 0 ;
27297 int temp3 ;
27298 int res3 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self", NULL
27302 };
27303
27304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27308 if (SWIG_arg_fail(1)) SWIG_fail;
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27312
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 Py_INCREF(Py_None); resultobj = Py_None;
27317 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27318 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27319 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27320 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj;
27329 wxWindow *arg1 = (wxWindow *) 0 ;
27330 wxSize result;
27331 PyObject * obj0 = 0 ;
27332 char *kwnames[] = {
27333 (char *) "self", NULL
27334 };
27335
27336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27338 if (SWIG_arg_fail(1)) SWIG_fail;
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27342
27343 wxPyEndAllowThreads(__tstate);
27344 if (PyErr_Occurred()) SWIG_fail;
27345 }
27346 {
27347 wxSize * resultptr;
27348 resultptr = new wxSize((wxSize &)(result));
27349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27350 }
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj;
27359 wxWindow *arg1 = (wxWindow *) 0 ;
27360 bool arg2 = (bool) true ;
27361 bool result;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 char *kwnames[] = {
27365 (char *) "self",(char *) "show", NULL
27366 };
27367
27368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27370 if (SWIG_arg_fail(1)) SWIG_fail;
27371 if (obj1) {
27372 {
27373 arg2 = (bool)(SWIG_As_bool(obj1));
27374 if (SWIG_arg_fail(2)) SWIG_fail;
27375 }
27376 }
27377 {
27378 PyThreadState* __tstate = wxPyBeginAllowThreads();
27379 result = (bool)(arg1)->Show(arg2);
27380
27381 wxPyEndAllowThreads(__tstate);
27382 if (PyErr_Occurred()) SWIG_fail;
27383 }
27384 {
27385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27386 }
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27394 PyObject *resultobj;
27395 wxWindow *arg1 = (wxWindow *) 0 ;
27396 bool result;
27397 PyObject * obj0 = 0 ;
27398 char *kwnames[] = {
27399 (char *) "self", NULL
27400 };
27401
27402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 {
27406 PyThreadState* __tstate = wxPyBeginAllowThreads();
27407 result = (bool)(arg1)->Hide();
27408
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 {
27413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27414 }
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27422 PyObject *resultobj;
27423 wxWindow *arg1 = (wxWindow *) 0 ;
27424 bool arg2 = (bool) true ;
27425 bool result;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 char *kwnames[] = {
27429 (char *) "self",(char *) "enable", NULL
27430 };
27431
27432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27434 if (SWIG_arg_fail(1)) SWIG_fail;
27435 if (obj1) {
27436 {
27437 arg2 = (bool)(SWIG_As_bool(obj1));
27438 if (SWIG_arg_fail(2)) SWIG_fail;
27439 }
27440 }
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = (bool)(arg1)->Enable(arg2);
27444
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 {
27449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27450 }
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27458 PyObject *resultobj;
27459 wxWindow *arg1 = (wxWindow *) 0 ;
27460 bool result;
27461 PyObject * obj0 = 0 ;
27462 char *kwnames[] = {
27463 (char *) "self", NULL
27464 };
27465
27466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27468 if (SWIG_arg_fail(1)) SWIG_fail;
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 result = (bool)(arg1)->Disable();
27472
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 {
27477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxWindow *arg1 = (wxWindow *) 0 ;
27488 bool result;
27489 PyObject * obj0 = 0 ;
27490 char *kwnames[] = {
27491 (char *) "self", NULL
27492 };
27493
27494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27496 if (SWIG_arg_fail(1)) SWIG_fail;
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = (bool)((wxWindow const *)arg1)->IsShown();
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 {
27505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27506 }
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj;
27515 wxWindow *arg1 = (wxWindow *) 0 ;
27516 bool result;
27517 PyObject * obj0 = 0 ;
27518 char *kwnames[] = {
27519 (char *) "self", NULL
27520 };
27521
27522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27524 if (SWIG_arg_fail(1)) SWIG_fail;
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27528
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 {
27533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27534 }
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj;
27543 wxWindow *arg1 = (wxWindow *) 0 ;
27544 long arg2 ;
27545 PyObject * obj0 = 0 ;
27546 PyObject * obj1 = 0 ;
27547 char *kwnames[] = {
27548 (char *) "self",(char *) "style", NULL
27549 };
27550
27551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27553 if (SWIG_arg_fail(1)) SWIG_fail;
27554 {
27555 arg2 = (long)(SWIG_As_long(obj1));
27556 if (SWIG_arg_fail(2)) SWIG_fail;
27557 }
27558 {
27559 PyThreadState* __tstate = wxPyBeginAllowThreads();
27560 (arg1)->SetWindowStyleFlag(arg2);
27561
27562 wxPyEndAllowThreads(__tstate);
27563 if (PyErr_Occurred()) SWIG_fail;
27564 }
27565 Py_INCREF(Py_None); resultobj = Py_None;
27566 return resultobj;
27567 fail:
27568 return NULL;
27569 }
27570
27571
27572 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27573 PyObject *resultobj;
27574 wxWindow *arg1 = (wxWindow *) 0 ;
27575 long result;
27576 PyObject * obj0 = 0 ;
27577 char *kwnames[] = {
27578 (char *) "self", NULL
27579 };
27580
27581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27583 if (SWIG_arg_fail(1)) SWIG_fail;
27584 {
27585 PyThreadState* __tstate = wxPyBeginAllowThreads();
27586 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27587
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 {
27592 resultobj = SWIG_From_long((long)(result));
27593 }
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxWindow *arg1 = (wxWindow *) 0 ;
27603 int arg2 ;
27604 bool result;
27605 PyObject * obj0 = 0 ;
27606 PyObject * obj1 = 0 ;
27607 char *kwnames[] = {
27608 (char *) "self",(char *) "flag", NULL
27609 };
27610
27611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27613 if (SWIG_arg_fail(1)) SWIG_fail;
27614 {
27615 arg2 = (int)(SWIG_As_int(obj1));
27616 if (SWIG_arg_fail(2)) SWIG_fail;
27617 }
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27621
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 {
27626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27627 }
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj;
27636 wxWindow *arg1 = (wxWindow *) 0 ;
27637 bool result;
27638 PyObject * obj0 = 0 ;
27639 char *kwnames[] = {
27640 (char *) "self", NULL
27641 };
27642
27643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27645 if (SWIG_arg_fail(1)) SWIG_fail;
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (bool)((wxWindow const *)arg1)->IsRetained();
27649
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 {
27654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27655 }
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27663 PyObject *resultobj;
27664 wxWindow *arg1 = (wxWindow *) 0 ;
27665 long arg2 ;
27666 PyObject * obj0 = 0 ;
27667 PyObject * obj1 = 0 ;
27668 char *kwnames[] = {
27669 (char *) "self",(char *) "exStyle", NULL
27670 };
27671
27672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27674 if (SWIG_arg_fail(1)) SWIG_fail;
27675 {
27676 arg2 = (long)(SWIG_As_long(obj1));
27677 if (SWIG_arg_fail(2)) SWIG_fail;
27678 }
27679 {
27680 PyThreadState* __tstate = wxPyBeginAllowThreads();
27681 (arg1)->SetExtraStyle(arg2);
27682
27683 wxPyEndAllowThreads(__tstate);
27684 if (PyErr_Occurred()) SWIG_fail;
27685 }
27686 Py_INCREF(Py_None); resultobj = Py_None;
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj;
27695 wxWindow *arg1 = (wxWindow *) 0 ;
27696 long result;
27697 PyObject * obj0 = 0 ;
27698 char *kwnames[] = {
27699 (char *) "self", NULL
27700 };
27701
27702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27704 if (SWIG_arg_fail(1)) SWIG_fail;
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27708
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 {
27713 resultobj = SWIG_From_long((long)(result));
27714 }
27715 return resultobj;
27716 fail:
27717 return NULL;
27718 }
27719
27720
27721 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27722 PyObject *resultobj;
27723 wxWindow *arg1 = (wxWindow *) 0 ;
27724 bool arg2 = (bool) true ;
27725 PyObject * obj0 = 0 ;
27726 PyObject * obj1 = 0 ;
27727 char *kwnames[] = {
27728 (char *) "self",(char *) "modal", NULL
27729 };
27730
27731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27733 if (SWIG_arg_fail(1)) SWIG_fail;
27734 if (obj1) {
27735 {
27736 arg2 = (bool)(SWIG_As_bool(obj1));
27737 if (SWIG_arg_fail(2)) SWIG_fail;
27738 }
27739 }
27740 {
27741 PyThreadState* __tstate = wxPyBeginAllowThreads();
27742 (arg1)->MakeModal(arg2);
27743
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 Py_INCREF(Py_None); resultobj = Py_None;
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27755 PyObject *resultobj;
27756 wxWindow *arg1 = (wxWindow *) 0 ;
27757 bool arg2 ;
27758 PyObject * obj0 = 0 ;
27759 PyObject * obj1 = 0 ;
27760 char *kwnames[] = {
27761 (char *) "self",(char *) "enableTheme", NULL
27762 };
27763
27764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27766 if (SWIG_arg_fail(1)) SWIG_fail;
27767 {
27768 arg2 = (bool)(SWIG_As_bool(obj1));
27769 if (SWIG_arg_fail(2)) SWIG_fail;
27770 }
27771 {
27772 PyThreadState* __tstate = wxPyBeginAllowThreads();
27773 (arg1)->SetThemeEnabled(arg2);
27774
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 Py_INCREF(Py_None); resultobj = Py_None;
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj;
27787 wxWindow *arg1 = (wxWindow *) 0 ;
27788 bool result;
27789 PyObject * obj0 = 0 ;
27790 char *kwnames[] = {
27791 (char *) "self", NULL
27792 };
27793
27794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27796 if (SWIG_arg_fail(1)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27800
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 {
27805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27806 }
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 PyObject * obj0 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "self", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27823 if (SWIG_arg_fail(1)) SWIG_fail;
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 (arg1)->SetFocus();
27827
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 Py_INCREF(Py_None); resultobj = Py_None;
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27839 PyObject *resultobj;
27840 wxWindow *arg1 = (wxWindow *) 0 ;
27841 PyObject * obj0 = 0 ;
27842 char *kwnames[] = {
27843 (char *) "self", NULL
27844 };
27845
27846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27848 if (SWIG_arg_fail(1)) SWIG_fail;
27849 {
27850 PyThreadState* __tstate = wxPyBeginAllowThreads();
27851 (arg1)->SetFocusFromKbd();
27852
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 Py_INCREF(Py_None); resultobj = Py_None;
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj;
27865 wxWindow *result;
27866 char *kwnames[] = {
27867 NULL
27868 };
27869
27870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27871 {
27872 if (!wxPyCheckForApp()) SWIG_fail;
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (wxWindow *)wxWindow::FindFocus();
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = wxPyMake_wxObject(result, 0);
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxWindow *arg1 = (wxWindow *) 0 ;
27891 bool result;
27892 PyObject * obj0 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27903
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj;
27918 wxWindow *arg1 = (wxWindow *) 0 ;
27919 bool result;
27920 PyObject * obj0 = 0 ;
27921 char *kwnames[] = {
27922 (char *) "self", NULL
27923 };
27924
27925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27927 if (SWIG_arg_fail(1)) SWIG_fail;
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27931
27932 wxPyEndAllowThreads(__tstate);
27933 if (PyErr_Occurred()) SWIG_fail;
27934 }
27935 {
27936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27937 }
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj;
27946 wxWindow *arg1 = (wxWindow *) 0 ;
27947 wxWindow *result;
27948 PyObject * obj0 = 0 ;
27949 char *kwnames[] = {
27950 (char *) "self", NULL
27951 };
27952
27953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27955 if (SWIG_arg_fail(1)) SWIG_fail;
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27959
27960 wxPyEndAllowThreads(__tstate);
27961 if (PyErr_Occurred()) SWIG_fail;
27962 }
27963 {
27964 resultobj = wxPyMake_wxObject(result, 0);
27965 }
27966 return resultobj;
27967 fail:
27968 return NULL;
27969 }
27970
27971
27972 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27973 PyObject *resultobj;
27974 wxWindow *arg1 = (wxWindow *) 0 ;
27975 wxWindow *arg2 = (wxWindow *) 0 ;
27976 wxWindow *result;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char *kwnames[] = {
27980 (char *) "self",(char *) "child", NULL
27981 };
27982
27983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(1)) SWIG_fail;
27986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27987 if (SWIG_arg_fail(2)) SWIG_fail;
27988 {
27989 PyThreadState* __tstate = wxPyBeginAllowThreads();
27990 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27991
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 {
27996 resultobj = wxPyMake_wxObject(result, 0);
27997 }
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj;
28006 wxWindow *arg1 = (wxWindow *) 0 ;
28007 wxWindow *arg2 = (wxWindow *) 0 ;
28008 PyObject * obj0 = 0 ;
28009 PyObject * obj1 = 0 ;
28010 char *kwnames[] = {
28011 (char *) "self",(char *) "win", NULL
28012 };
28013
28014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28016 if (SWIG_arg_fail(1)) SWIG_fail;
28017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(2)) SWIG_fail;
28019 {
28020 PyThreadState* __tstate = wxPyBeginAllowThreads();
28021 (arg1)->SetTmpDefaultItem(arg2);
28022
28023 wxPyEndAllowThreads(__tstate);
28024 if (PyErr_Occurred()) SWIG_fail;
28025 }
28026 Py_INCREF(Py_None); resultobj = Py_None;
28027 return resultobj;
28028 fail:
28029 return NULL;
28030 }
28031
28032
28033 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28034 PyObject *resultobj;
28035 wxWindow *arg1 = (wxWindow *) 0 ;
28036 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28037 bool result;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "self",(char *) "flags", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28046 if (SWIG_arg_fail(1)) SWIG_fail;
28047 if (obj1) {
28048 {
28049 arg2 = (int)(SWIG_As_int(obj1));
28050 if (SWIG_arg_fail(2)) SWIG_fail;
28051 }
28052 }
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (bool)(arg1)->Navigate(arg2);
28056
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 {
28061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28062 }
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj;
28071 wxWindow *arg1 = (wxWindow *) 0 ;
28072 wxWindow *arg2 = (wxWindow *) 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char *kwnames[] = {
28076 (char *) "self",(char *) "win", NULL
28077 };
28078
28079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28081 if (SWIG_arg_fail(1)) SWIG_fail;
28082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28083 if (SWIG_arg_fail(2)) SWIG_fail;
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 (arg1)->MoveAfterInTabOrder(arg2);
28087
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 Py_INCREF(Py_None); resultobj = Py_None;
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj;
28100 wxWindow *arg1 = (wxWindow *) 0 ;
28101 wxWindow *arg2 = (wxWindow *) 0 ;
28102 PyObject * obj0 = 0 ;
28103 PyObject * obj1 = 0 ;
28104 char *kwnames[] = {
28105 (char *) "self",(char *) "win", NULL
28106 };
28107
28108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28110 if (SWIG_arg_fail(1)) SWIG_fail;
28111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28112 if (SWIG_arg_fail(2)) SWIG_fail;
28113 {
28114 PyThreadState* __tstate = wxPyBeginAllowThreads();
28115 (arg1)->MoveBeforeInTabOrder(arg2);
28116
28117 wxPyEndAllowThreads(__tstate);
28118 if (PyErr_Occurred()) SWIG_fail;
28119 }
28120 Py_INCREF(Py_None); resultobj = Py_None;
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj;
28129 wxWindow *arg1 = (wxWindow *) 0 ;
28130 PyObject *result;
28131 PyObject * obj0 = 0 ;
28132 char *kwnames[] = {
28133 (char *) "self", NULL
28134 };
28135
28136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28138 if (SWIG_arg_fail(1)) SWIG_fail;
28139 {
28140 PyThreadState* __tstate = wxPyBeginAllowThreads();
28141 result = (PyObject *)wxWindow_GetChildren(arg1);
28142
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = result;
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj;
28155 wxWindow *arg1 = (wxWindow *) 0 ;
28156 wxWindow *result;
28157 PyObject * obj0 = 0 ;
28158 char *kwnames[] = {
28159 (char *) "self", NULL
28160 };
28161
28162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28164 if (SWIG_arg_fail(1)) SWIG_fail;
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28168
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 {
28173 resultobj = wxPyMake_wxObject(result, 0);
28174 }
28175 return resultobj;
28176 fail:
28177 return NULL;
28178 }
28179
28180
28181 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28182 PyObject *resultobj;
28183 wxWindow *arg1 = (wxWindow *) 0 ;
28184 wxWindow *result;
28185 PyObject * obj0 = 0 ;
28186 char *kwnames[] = {
28187 (char *) "self", NULL
28188 };
28189
28190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28192 if (SWIG_arg_fail(1)) SWIG_fail;
28193 {
28194 PyThreadState* __tstate = wxPyBeginAllowThreads();
28195 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28196
28197 wxPyEndAllowThreads(__tstate);
28198 if (PyErr_Occurred()) SWIG_fail;
28199 }
28200 {
28201 resultobj = wxPyMake_wxObject(result, 0);
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj;
28211 wxWindow *arg1 = (wxWindow *) 0 ;
28212 bool result;
28213 PyObject * obj0 = 0 ;
28214 char *kwnames[] = {
28215 (char *) "self", NULL
28216 };
28217
28218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28220 if (SWIG_arg_fail(1)) SWIG_fail;
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28224
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 {
28229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28230 }
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj;
28239 wxWindow *arg1 = (wxWindow *) 0 ;
28240 wxWindow *arg2 = (wxWindow *) 0 ;
28241 bool result;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 char *kwnames[] = {
28245 (char *) "self",(char *) "newParent", NULL
28246 };
28247
28248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28250 if (SWIG_arg_fail(1)) SWIG_fail;
28251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28252 if (SWIG_arg_fail(2)) SWIG_fail;
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 result = (bool)(arg1)->Reparent(arg2);
28256
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 {
28261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28262 }
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj;
28271 wxWindow *arg1 = (wxWindow *) 0 ;
28272 wxWindow *arg2 = (wxWindow *) 0 ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self",(char *) "child", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(2)) SWIG_fail;
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 (arg1)->AddChild(arg2);
28287
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 Py_INCREF(Py_None); resultobj = Py_None;
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj;
28300 wxWindow *arg1 = (wxWindow *) 0 ;
28301 wxWindow *arg2 = (wxWindow *) 0 ;
28302 PyObject * obj0 = 0 ;
28303 PyObject * obj1 = 0 ;
28304 char *kwnames[] = {
28305 (char *) "self",(char *) "child", NULL
28306 };
28307
28308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28310 if (SWIG_arg_fail(1)) SWIG_fail;
28311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28312 if (SWIG_arg_fail(2)) SWIG_fail;
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 (arg1)->RemoveChild(arg2);
28316
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 Py_INCREF(Py_None); resultobj = Py_None;
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28328 PyObject *resultobj;
28329 wxWindow *arg1 = (wxWindow *) 0 ;
28330 long arg2 ;
28331 wxWindow *result;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 char *kwnames[] = {
28335 (char *) "self",(char *) "winid", NULL
28336 };
28337
28338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28340 if (SWIG_arg_fail(1)) SWIG_fail;
28341 {
28342 arg2 = (long)(SWIG_As_long(obj1));
28343 if (SWIG_arg_fail(2)) SWIG_fail;
28344 }
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (wxWindow *)(arg1)->FindWindow(arg2);
28348
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 {
28353 resultobj = wxPyMake_wxObject(result, 0);
28354 }
28355 return resultobj;
28356 fail:
28357 return NULL;
28358 }
28359
28360
28361 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28362 PyObject *resultobj;
28363 wxWindow *arg1 = (wxWindow *) 0 ;
28364 wxString *arg2 = 0 ;
28365 wxWindow *result;
28366 bool temp2 = false ;
28367 PyObject * obj0 = 0 ;
28368 PyObject * obj1 = 0 ;
28369 char *kwnames[] = {
28370 (char *) "self",(char *) "name", NULL
28371 };
28372
28373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28375 if (SWIG_arg_fail(1)) SWIG_fail;
28376 {
28377 arg2 = wxString_in_helper(obj1);
28378 if (arg2 == NULL) SWIG_fail;
28379 temp2 = true;
28380 }
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28384
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 {
28389 resultobj = wxPyMake_wxObject(result, 0);
28390 }
28391 {
28392 if (temp2)
28393 delete arg2;
28394 }
28395 return resultobj;
28396 fail:
28397 {
28398 if (temp2)
28399 delete arg2;
28400 }
28401 return NULL;
28402 }
28403
28404
28405 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj;
28407 wxWindow *arg1 = (wxWindow *) 0 ;
28408 wxEvtHandler *result;
28409 PyObject * obj0 = 0 ;
28410 char *kwnames[] = {
28411 (char *) "self", NULL
28412 };
28413
28414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28416 if (SWIG_arg_fail(1)) SWIG_fail;
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28420
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 {
28425 resultobj = wxPyMake_wxObject(result, 0);
28426 }
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj;
28435 wxWindow *arg1 = (wxWindow *) 0 ;
28436 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28437 PyObject * obj0 = 0 ;
28438 PyObject * obj1 = 0 ;
28439 char *kwnames[] = {
28440 (char *) "self",(char *) "handler", NULL
28441 };
28442
28443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28445 if (SWIG_arg_fail(1)) SWIG_fail;
28446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28447 if (SWIG_arg_fail(2)) SWIG_fail;
28448 {
28449 PyThreadState* __tstate = wxPyBeginAllowThreads();
28450 (arg1)->SetEventHandler(arg2);
28451
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 Py_INCREF(Py_None); resultobj = Py_None;
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj;
28464 wxWindow *arg1 = (wxWindow *) 0 ;
28465 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28466 PyObject * obj0 = 0 ;
28467 PyObject * obj1 = 0 ;
28468 char *kwnames[] = {
28469 (char *) "self",(char *) "handler", NULL
28470 };
28471
28472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(1)) SWIG_fail;
28475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28476 if (SWIG_arg_fail(2)) SWIG_fail;
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->PushEventHandler(arg2);
28480
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 Py_INCREF(Py_None); resultobj = Py_None;
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj;
28493 wxWindow *arg1 = (wxWindow *) 0 ;
28494 bool arg2 = (bool) false ;
28495 wxEvtHandler *result;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char *kwnames[] = {
28499 (char *) "self",(char *) "deleteHandler", NULL
28500 };
28501
28502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28504 if (SWIG_arg_fail(1)) SWIG_fail;
28505 if (obj1) {
28506 {
28507 arg2 = (bool)(SWIG_As_bool(obj1));
28508 if (SWIG_arg_fail(2)) SWIG_fail;
28509 }
28510 }
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28514
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 {
28519 resultobj = wxPyMake_wxObject(result, 0);
28520 }
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28528 PyObject *resultobj;
28529 wxWindow *arg1 = (wxWindow *) 0 ;
28530 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28531 bool result;
28532 PyObject * obj0 = 0 ;
28533 PyObject * obj1 = 0 ;
28534 char *kwnames[] = {
28535 (char *) "self",(char *) "handler", NULL
28536 };
28537
28538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(1)) SWIG_fail;
28541 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28542 if (SWIG_arg_fail(2)) SWIG_fail;
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)(arg1)->RemoveEventHandler(arg2);
28546
28547 wxPyEndAllowThreads(__tstate);
28548 if (PyErr_Occurred()) SWIG_fail;
28549 }
28550 {
28551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28552 }
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28560 PyObject *resultobj;
28561 wxWindow *arg1 = (wxWindow *) 0 ;
28562 wxValidator *arg2 = 0 ;
28563 PyObject * obj0 = 0 ;
28564 PyObject * obj1 = 0 ;
28565 char *kwnames[] = {
28566 (char *) "self",(char *) "validator", NULL
28567 };
28568
28569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28571 if (SWIG_arg_fail(1)) SWIG_fail;
28572 {
28573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(2)) SWIG_fail;
28575 if (arg2 == NULL) {
28576 SWIG_null_ref("wxValidator");
28577 }
28578 if (SWIG_arg_fail(2)) SWIG_fail;
28579 }
28580 {
28581 PyThreadState* __tstate = wxPyBeginAllowThreads();
28582 (arg1)->SetValidator((wxValidator const &)*arg2);
28583
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 Py_INCREF(Py_None); resultobj = Py_None;
28588 return resultobj;
28589 fail:
28590 return NULL;
28591 }
28592
28593
28594 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28595 PyObject *resultobj;
28596 wxWindow *arg1 = (wxWindow *) 0 ;
28597 wxValidator *result;
28598 PyObject * obj0 = 0 ;
28599 char *kwnames[] = {
28600 (char *) "self", NULL
28601 };
28602
28603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28605 if (SWIG_arg_fail(1)) SWIG_fail;
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 result = (wxValidator *)(arg1)->GetValidator();
28609
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 {
28614 resultobj = wxPyMake_wxObject(result, 0);
28615 }
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj;
28624 wxWindow *arg1 = (wxWindow *) 0 ;
28625 bool result;
28626 PyObject * obj0 = 0 ;
28627 char *kwnames[] = {
28628 (char *) "self", NULL
28629 };
28630
28631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28633 if (SWIG_arg_fail(1)) SWIG_fail;
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (bool)(arg1)->Validate();
28637
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 {
28642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28643 }
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj;
28652 wxWindow *arg1 = (wxWindow *) 0 ;
28653 bool result;
28654 PyObject * obj0 = 0 ;
28655 char *kwnames[] = {
28656 (char *) "self", NULL
28657 };
28658
28659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28661 if (SWIG_arg_fail(1)) SWIG_fail;
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 result = (bool)(arg1)->TransferDataToWindow();
28665
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 {
28670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28671 }
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj;
28680 wxWindow *arg1 = (wxWindow *) 0 ;
28681 bool result;
28682 PyObject * obj0 = 0 ;
28683 char *kwnames[] = {
28684 (char *) "self", NULL
28685 };
28686
28687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(1)) SWIG_fail;
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 result = (bool)(arg1)->TransferDataFromWindow();
28693
28694 wxPyEndAllowThreads(__tstate);
28695 if (PyErr_Occurred()) SWIG_fail;
28696 }
28697 {
28698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28699 }
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28707 PyObject *resultobj;
28708 wxWindow *arg1 = (wxWindow *) 0 ;
28709 PyObject * obj0 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 (arg1)->InitDialog();
28720
28721 wxPyEndAllowThreads(__tstate);
28722 if (PyErr_Occurred()) SWIG_fail;
28723 }
28724 Py_INCREF(Py_None); resultobj = Py_None;
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj;
28733 wxWindow *arg1 = (wxWindow *) 0 ;
28734 wxAcceleratorTable *arg2 = 0 ;
28735 PyObject * obj0 = 0 ;
28736 PyObject * obj1 = 0 ;
28737 char *kwnames[] = {
28738 (char *) "self",(char *) "accel", NULL
28739 };
28740
28741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28743 if (SWIG_arg_fail(1)) SWIG_fail;
28744 {
28745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28746 if (SWIG_arg_fail(2)) SWIG_fail;
28747 if (arg2 == NULL) {
28748 SWIG_null_ref("wxAcceleratorTable");
28749 }
28750 if (SWIG_arg_fail(2)) SWIG_fail;
28751 }
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28755
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 Py_INCREF(Py_None); resultobj = Py_None;
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxWindow *arg1 = (wxWindow *) 0 ;
28769 wxAcceleratorTable *result;
28770 PyObject * obj0 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28793 PyObject *resultobj;
28794 wxWindow *arg1 = (wxWindow *) 0 ;
28795 int arg2 ;
28796 int arg3 ;
28797 int arg4 ;
28798 bool result;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 PyObject * obj2 = 0 ;
28802 PyObject * obj3 = 0 ;
28803 char *kwnames[] = {
28804 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28805 };
28806
28807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28809 if (SWIG_arg_fail(1)) SWIG_fail;
28810 {
28811 arg2 = (int)(SWIG_As_int(obj1));
28812 if (SWIG_arg_fail(2)) SWIG_fail;
28813 }
28814 {
28815 arg3 = (int)(SWIG_As_int(obj2));
28816 if (SWIG_arg_fail(3)) SWIG_fail;
28817 }
28818 {
28819 arg4 = (int)(SWIG_As_int(obj3));
28820 if (SWIG_arg_fail(4)) SWIG_fail;
28821 }
28822 {
28823 PyThreadState* __tstate = wxPyBeginAllowThreads();
28824 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28825
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 {
28830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28831 }
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28839 PyObject *resultobj;
28840 wxWindow *arg1 = (wxWindow *) 0 ;
28841 int arg2 ;
28842 bool result;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "hotkeyId", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 {
28853 arg2 = (int)(SWIG_As_int(obj1));
28854 if (SWIG_arg_fail(2)) SWIG_fail;
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 {
28864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28865 }
28866 return resultobj;
28867 fail:
28868 return NULL;
28869 }
28870
28871
28872 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28873 PyObject *resultobj;
28874 wxWindow *arg1 = (wxWindow *) 0 ;
28875 wxPoint *arg2 = 0 ;
28876 wxPoint result;
28877 wxPoint temp2 ;
28878 PyObject * obj0 = 0 ;
28879 PyObject * obj1 = 0 ;
28880 char *kwnames[] = {
28881 (char *) "self",(char *) "pt", NULL
28882 };
28883
28884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28886 if (SWIG_arg_fail(1)) SWIG_fail;
28887 {
28888 arg2 = &temp2;
28889 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28890 }
28891 {
28892 PyThreadState* __tstate = wxPyBeginAllowThreads();
28893 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28894
28895 wxPyEndAllowThreads(__tstate);
28896 if (PyErr_Occurred()) SWIG_fail;
28897 }
28898 {
28899 wxPoint * resultptr;
28900 resultptr = new wxPoint((wxPoint &)(result));
28901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28902 }
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj;
28911 wxWindow *arg1 = (wxWindow *) 0 ;
28912 wxSize *arg2 = 0 ;
28913 wxSize result;
28914 wxSize temp2 ;
28915 PyObject * obj0 = 0 ;
28916 PyObject * obj1 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self",(char *) "sz", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 {
28925 arg2 = &temp2;
28926 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28927 }
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28931
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 {
28936 wxSize * resultptr;
28937 resultptr = new wxSize((wxSize &)(result));
28938 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28939 }
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28947 PyObject *resultobj;
28948 wxWindow *arg1 = (wxWindow *) 0 ;
28949 wxPoint *arg2 = 0 ;
28950 wxPoint result;
28951 wxPoint temp2 ;
28952 PyObject * obj0 = 0 ;
28953 PyObject * obj1 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self",(char *) "pt", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 {
28962 arg2 = &temp2;
28963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28964 }
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28968
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 {
28973 wxPoint * resultptr;
28974 resultptr = new wxPoint((wxPoint &)(result));
28975 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28976 }
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj;
28985 wxWindow *arg1 = (wxWindow *) 0 ;
28986 wxSize *arg2 = 0 ;
28987 wxSize result;
28988 wxSize temp2 ;
28989 PyObject * obj0 = 0 ;
28990 PyObject * obj1 = 0 ;
28991 char *kwnames[] = {
28992 (char *) "self",(char *) "sz", NULL
28993 };
28994
28995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28997 if (SWIG_arg_fail(1)) SWIG_fail;
28998 {
28999 arg2 = &temp2;
29000 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29001 }
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29005
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 {
29010 wxSize * resultptr;
29011 resultptr = new wxSize((wxSize &)(result));
29012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29013 }
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj;
29022 wxWindow *arg1 = (wxWindow *) 0 ;
29023 wxPoint *arg2 = 0 ;
29024 wxPoint result;
29025 wxPoint temp2 ;
29026 PyObject * obj0 = 0 ;
29027 PyObject * obj1 = 0 ;
29028 char *kwnames[] = {
29029 (char *) "self",(char *) "pt", NULL
29030 };
29031
29032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29034 if (SWIG_arg_fail(1)) SWIG_fail;
29035 {
29036 arg2 = &temp2;
29037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29038 }
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29042
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 {
29047 wxPoint * resultptr;
29048 resultptr = new wxPoint((wxPoint &)(result));
29049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29050 }
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj;
29059 wxWindow *arg1 = (wxWindow *) 0 ;
29060 wxSize *arg2 = 0 ;
29061 wxSize result;
29062 wxSize temp2 ;
29063 PyObject * obj0 = 0 ;
29064 PyObject * obj1 = 0 ;
29065 char *kwnames[] = {
29066 (char *) "self",(char *) "sz", NULL
29067 };
29068
29069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29071 if (SWIG_arg_fail(1)) SWIG_fail;
29072 {
29073 arg2 = &temp2;
29074 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29075 }
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 {
29084 wxSize * resultptr;
29085 resultptr = new wxSize((wxSize &)(result));
29086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29087 }
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29095 PyObject *resultobj;
29096 wxWindow *arg1 = (wxWindow *) 0 ;
29097 int arg2 ;
29098 int arg3 ;
29099 PyObject * obj0 = 0 ;
29100 PyObject * obj1 = 0 ;
29101 PyObject * obj2 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "x",(char *) "y", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 arg2 = (int)(SWIG_As_int(obj1));
29111 if (SWIG_arg_fail(2)) SWIG_fail;
29112 }
29113 {
29114 arg3 = (int)(SWIG_As_int(obj2));
29115 if (SWIG_arg_fail(3)) SWIG_fail;
29116 }
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 (arg1)->WarpPointer(arg2,arg3);
29120
29121 wxPyEndAllowThreads(__tstate);
29122 if (PyErr_Occurred()) SWIG_fail;
29123 }
29124 Py_INCREF(Py_None); resultobj = Py_None;
29125 return resultobj;
29126 fail:
29127 return NULL;
29128 }
29129
29130
29131 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj;
29133 wxWindow *arg1 = (wxWindow *) 0 ;
29134 PyObject * obj0 = 0 ;
29135 char *kwnames[] = {
29136 (char *) "self", NULL
29137 };
29138
29139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29141 if (SWIG_arg_fail(1)) SWIG_fail;
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 (arg1)->CaptureMouse();
29145
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 Py_INCREF(Py_None); resultobj = Py_None;
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj;
29158 wxWindow *arg1 = (wxWindow *) 0 ;
29159 PyObject * obj0 = 0 ;
29160 char *kwnames[] = {
29161 (char *) "self", NULL
29162 };
29163
29164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29166 if (SWIG_arg_fail(1)) SWIG_fail;
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 (arg1)->ReleaseMouse();
29170
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 Py_INCREF(Py_None); resultobj = Py_None;
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxWindow *result;
29184 char *kwnames[] = {
29185 NULL
29186 };
29187
29188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29189 {
29190 if (!wxPyCheckForApp()) SWIG_fail;
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = (wxWindow *)wxWindow::GetCapture();
29193
29194 wxPyEndAllowThreads(__tstate);
29195 if (PyErr_Occurred()) SWIG_fail;
29196 }
29197 {
29198 resultobj = wxPyMake_wxObject(result, 0);
29199 }
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29207 PyObject *resultobj;
29208 wxWindow *arg1 = (wxWindow *) 0 ;
29209 bool result;
29210 PyObject * obj0 = 0 ;
29211 char *kwnames[] = {
29212 (char *) "self", NULL
29213 };
29214
29215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29217 if (SWIG_arg_fail(1)) SWIG_fail;
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 result = (bool)((wxWindow const *)arg1)->HasCapture();
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 {
29226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29227 }
29228 return resultobj;
29229 fail:
29230 return NULL;
29231 }
29232
29233
29234 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29235 PyObject *resultobj;
29236 wxWindow *arg1 = (wxWindow *) 0 ;
29237 bool arg2 = (bool) true ;
29238 wxRect *arg3 = (wxRect *) NULL ;
29239 PyObject * obj0 = 0 ;
29240 PyObject * obj1 = 0 ;
29241 PyObject * obj2 = 0 ;
29242 char *kwnames[] = {
29243 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29244 };
29245
29246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29248 if (SWIG_arg_fail(1)) SWIG_fail;
29249 if (obj1) {
29250 {
29251 arg2 = (bool)(SWIG_As_bool(obj1));
29252 if (SWIG_arg_fail(2)) SWIG_fail;
29253 }
29254 }
29255 if (obj2) {
29256 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(3)) SWIG_fail;
29258 }
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29262
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 Py_INCREF(Py_None); resultobj = Py_None;
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj;
29275 wxWindow *arg1 = (wxWindow *) 0 ;
29276 wxRect *arg2 = 0 ;
29277 bool arg3 = (bool) true ;
29278 wxRect temp2 ;
29279 PyObject * obj0 = 0 ;
29280 PyObject * obj1 = 0 ;
29281 PyObject * obj2 = 0 ;
29282 char *kwnames[] = {
29283 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29284 };
29285
29286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29288 if (SWIG_arg_fail(1)) SWIG_fail;
29289 {
29290 arg2 = &temp2;
29291 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29292 }
29293 if (obj2) {
29294 {
29295 arg3 = (bool)(SWIG_As_bool(obj2));
29296 if (SWIG_arg_fail(3)) SWIG_fail;
29297 }
29298 }
29299 {
29300 PyThreadState* __tstate = wxPyBeginAllowThreads();
29301 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29302
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 Py_INCREF(Py_None); resultobj = Py_None;
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj;
29315 wxWindow *arg1 = (wxWindow *) 0 ;
29316 PyObject * obj0 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 (arg1)->Update();
29327
29328 wxPyEndAllowThreads(__tstate);
29329 if (PyErr_Occurred()) SWIG_fail;
29330 }
29331 Py_INCREF(Py_None); resultobj = Py_None;
29332 return resultobj;
29333 fail:
29334 return NULL;
29335 }
29336
29337
29338 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29339 PyObject *resultobj;
29340 wxWindow *arg1 = (wxWindow *) 0 ;
29341 PyObject * obj0 = 0 ;
29342 char *kwnames[] = {
29343 (char *) "self", NULL
29344 };
29345
29346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29348 if (SWIG_arg_fail(1)) SWIG_fail;
29349 {
29350 PyThreadState* __tstate = wxPyBeginAllowThreads();
29351 (arg1)->ClearBackground();
29352
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 Py_INCREF(Py_None); resultobj = Py_None;
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj;
29365 wxWindow *arg1 = (wxWindow *) 0 ;
29366 PyObject * obj0 = 0 ;
29367 char *kwnames[] = {
29368 (char *) "self", NULL
29369 };
29370
29371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29373 if (SWIG_arg_fail(1)) SWIG_fail;
29374 {
29375 PyThreadState* __tstate = wxPyBeginAllowThreads();
29376 (arg1)->Freeze();
29377
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 Py_INCREF(Py_None); resultobj = Py_None;
29382 return resultobj;
29383 fail:
29384 return NULL;
29385 }
29386
29387
29388 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj;
29390 wxWindow *arg1 = (wxWindow *) 0 ;
29391 PyObject * obj0 = 0 ;
29392 char *kwnames[] = {
29393 (char *) "self", NULL
29394 };
29395
29396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29398 if (SWIG_arg_fail(1)) SWIG_fail;
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 (arg1)->Thaw();
29402
29403 wxPyEndAllowThreads(__tstate);
29404 if (PyErr_Occurred()) SWIG_fail;
29405 }
29406 Py_INCREF(Py_None); resultobj = Py_None;
29407 return resultobj;
29408 fail:
29409 return NULL;
29410 }
29411
29412
29413 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29414 PyObject *resultobj;
29415 wxWindow *arg1 = (wxWindow *) 0 ;
29416 wxDC *arg2 = 0 ;
29417 PyObject * obj0 = 0 ;
29418 PyObject * obj1 = 0 ;
29419 char *kwnames[] = {
29420 (char *) "self",(char *) "dc", NULL
29421 };
29422
29423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29425 if (SWIG_arg_fail(1)) SWIG_fail;
29426 {
29427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29428 if (SWIG_arg_fail(2)) SWIG_fail;
29429 if (arg2 == NULL) {
29430 SWIG_null_ref("wxDC");
29431 }
29432 if (SWIG_arg_fail(2)) SWIG_fail;
29433 }
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 (arg1)->PrepareDC(*arg2);
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 Py_INCREF(Py_None); resultobj = Py_None;
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29449 PyObject *resultobj;
29450 wxWindow *arg1 = (wxWindow *) 0 ;
29451 wxRegion *result;
29452 PyObject * obj0 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 {
29463 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29464 result = (wxRegion *) &_result_ref;
29465 }
29466
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj;
29479 wxWindow *arg1 = (wxWindow *) 0 ;
29480 wxRect result;
29481 PyObject * obj0 = 0 ;
29482 char *kwnames[] = {
29483 (char *) "self", NULL
29484 };
29485
29486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(1)) SWIG_fail;
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29492
29493 wxPyEndAllowThreads(__tstate);
29494 if (PyErr_Occurred()) SWIG_fail;
29495 }
29496 {
29497 wxRect * resultptr;
29498 resultptr = new wxRect((wxRect &)(result));
29499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29500 }
29501 return resultobj;
29502 fail:
29503 return NULL;
29504 }
29505
29506
29507 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29508 PyObject *resultobj;
29509 wxWindow *arg1 = (wxWindow *) 0 ;
29510 int arg2 ;
29511 int arg3 ;
29512 int arg4 = (int) 1 ;
29513 int arg5 = (int) 1 ;
29514 bool result;
29515 PyObject * obj0 = 0 ;
29516 PyObject * obj1 = 0 ;
29517 PyObject * obj2 = 0 ;
29518 PyObject * obj3 = 0 ;
29519 PyObject * obj4 = 0 ;
29520 char *kwnames[] = {
29521 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29522 };
29523
29524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29526 if (SWIG_arg_fail(1)) SWIG_fail;
29527 {
29528 arg2 = (int)(SWIG_As_int(obj1));
29529 if (SWIG_arg_fail(2)) SWIG_fail;
29530 }
29531 {
29532 arg3 = (int)(SWIG_As_int(obj2));
29533 if (SWIG_arg_fail(3)) SWIG_fail;
29534 }
29535 if (obj3) {
29536 {
29537 arg4 = (int)(SWIG_As_int(obj3));
29538 if (SWIG_arg_fail(4)) SWIG_fail;
29539 }
29540 }
29541 if (obj4) {
29542 {
29543 arg5 = (int)(SWIG_As_int(obj4));
29544 if (SWIG_arg_fail(5)) SWIG_fail;
29545 }
29546 }
29547 {
29548 PyThreadState* __tstate = wxPyBeginAllowThreads();
29549 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29550
29551 wxPyEndAllowThreads(__tstate);
29552 if (PyErr_Occurred()) SWIG_fail;
29553 }
29554 {
29555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29556 }
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj;
29565 wxWindow *arg1 = (wxWindow *) 0 ;
29566 wxPoint *arg2 = 0 ;
29567 bool result;
29568 wxPoint temp2 ;
29569 PyObject * obj0 = 0 ;
29570 PyObject * obj1 = 0 ;
29571 char *kwnames[] = {
29572 (char *) "self",(char *) "pt", NULL
29573 };
29574
29575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29577 if (SWIG_arg_fail(1)) SWIG_fail;
29578 {
29579 arg2 = &temp2;
29580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29581 }
29582 {
29583 PyThreadState* __tstate = wxPyBeginAllowThreads();
29584 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29585
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 {
29590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29591 }
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29599 PyObject *resultobj;
29600 wxWindow *arg1 = (wxWindow *) 0 ;
29601 wxRect *arg2 = 0 ;
29602 bool result;
29603 wxRect temp2 ;
29604 PyObject * obj0 = 0 ;
29605 PyObject * obj1 = 0 ;
29606 char *kwnames[] = {
29607 (char *) "self",(char *) "rect", NULL
29608 };
29609
29610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29612 if (SWIG_arg_fail(1)) SWIG_fail;
29613 {
29614 arg2 = &temp2;
29615 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29616 }
29617 {
29618 PyThreadState* __tstate = wxPyBeginAllowThreads();
29619 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29620
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 {
29625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29626 }
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj;
29635 wxWindow *arg1 = (wxWindow *) 0 ;
29636 wxVisualAttributes result;
29637 PyObject * obj0 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(1)) SWIG_fail;
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29648
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 {
29653 wxVisualAttributes * resultptr;
29654 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29656 }
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj;
29665 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29666 wxVisualAttributes result;
29667 PyObject * obj0 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "variant", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29673 if (obj0) {
29674 {
29675 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 }
29678 }
29679 {
29680 if (!wxPyCheckForApp()) SWIG_fail;
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29683
29684 wxPyEndAllowThreads(__tstate);
29685 if (PyErr_Occurred()) SWIG_fail;
29686 }
29687 {
29688 wxVisualAttributes * resultptr;
29689 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29691 }
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj;
29700 wxWindow *arg1 = (wxWindow *) 0 ;
29701 wxColour *arg2 = 0 ;
29702 bool result;
29703 wxColour temp2 ;
29704 PyObject * obj0 = 0 ;
29705 PyObject * obj1 = 0 ;
29706 char *kwnames[] = {
29707 (char *) "self",(char *) "colour", NULL
29708 };
29709
29710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29712 if (SWIG_arg_fail(1)) SWIG_fail;
29713 {
29714 arg2 = &temp2;
29715 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29716 }
29717 {
29718 PyThreadState* __tstate = wxPyBeginAllowThreads();
29719 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29720
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 {
29725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29726 }
29727 return resultobj;
29728 fail:
29729 return NULL;
29730 }
29731
29732
29733 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29734 PyObject *resultobj;
29735 wxWindow *arg1 = (wxWindow *) 0 ;
29736 wxColour *arg2 = 0 ;
29737 wxColour temp2 ;
29738 PyObject * obj0 = 0 ;
29739 PyObject * obj1 = 0 ;
29740 char *kwnames[] = {
29741 (char *) "self",(char *) "colour", NULL
29742 };
29743
29744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(1)) SWIG_fail;
29747 {
29748 arg2 = &temp2;
29749 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29750 }
29751 {
29752 PyThreadState* __tstate = wxPyBeginAllowThreads();
29753 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29754
29755 wxPyEndAllowThreads(__tstate);
29756 if (PyErr_Occurred()) SWIG_fail;
29757 }
29758 Py_INCREF(Py_None); resultobj = Py_None;
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj;
29767 wxWindow *arg1 = (wxWindow *) 0 ;
29768 wxColour *arg2 = 0 ;
29769 bool result;
29770 wxColour temp2 ;
29771 PyObject * obj0 = 0 ;
29772 PyObject * obj1 = 0 ;
29773 char *kwnames[] = {
29774 (char *) "self",(char *) "colour", NULL
29775 };
29776
29777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29779 if (SWIG_arg_fail(1)) SWIG_fail;
29780 {
29781 arg2 = &temp2;
29782 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29783 }
29784 {
29785 PyThreadState* __tstate = wxPyBeginAllowThreads();
29786 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29787
29788 wxPyEndAllowThreads(__tstate);
29789 if (PyErr_Occurred()) SWIG_fail;
29790 }
29791 {
29792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29793 }
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29801 PyObject *resultobj;
29802 wxWindow *arg1 = (wxWindow *) 0 ;
29803 wxColour *arg2 = 0 ;
29804 wxColour temp2 ;
29805 PyObject * obj0 = 0 ;
29806 PyObject * obj1 = 0 ;
29807 char *kwnames[] = {
29808 (char *) "self",(char *) "colour", NULL
29809 };
29810
29811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29813 if (SWIG_arg_fail(1)) SWIG_fail;
29814 {
29815 arg2 = &temp2;
29816 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29817 }
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29821
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 Py_INCREF(Py_None); resultobj = Py_None;
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj;
29834 wxWindow *arg1 = (wxWindow *) 0 ;
29835 wxColour result;
29836 PyObject * obj0 = 0 ;
29837 char *kwnames[] = {
29838 (char *) "self", NULL
29839 };
29840
29841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29843 if (SWIG_arg_fail(1)) SWIG_fail;
29844 {
29845 PyThreadState* __tstate = wxPyBeginAllowThreads();
29846 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29847
29848 wxPyEndAllowThreads(__tstate);
29849 if (PyErr_Occurred()) SWIG_fail;
29850 }
29851 {
29852 wxColour * resultptr;
29853 resultptr = new wxColour((wxColour &)(result));
29854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29855 }
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29863 PyObject *resultobj;
29864 wxWindow *arg1 = (wxWindow *) 0 ;
29865 wxColour result;
29866 PyObject * obj0 = 0 ;
29867 char *kwnames[] = {
29868 (char *) "self", NULL
29869 };
29870
29871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29873 if (SWIG_arg_fail(1)) SWIG_fail;
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 result = ((wxWindow const *)arg1)->GetForegroundColour();
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 {
29882 wxColour * resultptr;
29883 resultptr = new wxColour((wxColour &)(result));
29884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29885 }
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29893 PyObject *resultobj;
29894 wxWindow *arg1 = (wxWindow *) 0 ;
29895 bool result;
29896 PyObject * obj0 = 0 ;
29897 char *kwnames[] = {
29898 (char *) "self", NULL
29899 };
29900
29901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29903 if (SWIG_arg_fail(1)) SWIG_fail;
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 {
29912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29913 }
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj;
29922 wxWindow *arg1 = (wxWindow *) 0 ;
29923 bool result;
29924 PyObject * obj0 = 0 ;
29925 char *kwnames[] = {
29926 (char *) "self", NULL
29927 };
29928
29929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29931 if (SWIG_arg_fail(1)) SWIG_fail;
29932 {
29933 PyThreadState* __tstate = wxPyBeginAllowThreads();
29934 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29935
29936 wxPyEndAllowThreads(__tstate);
29937 if (PyErr_Occurred()) SWIG_fail;
29938 }
29939 {
29940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29941 }
29942 return resultobj;
29943 fail:
29944 return NULL;
29945 }
29946
29947
29948 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29949 PyObject *resultobj;
29950 wxWindow *arg1 = (wxWindow *) 0 ;
29951 wxBackgroundStyle arg2 ;
29952 bool result;
29953 PyObject * obj0 = 0 ;
29954 PyObject * obj1 = 0 ;
29955 char *kwnames[] = {
29956 (char *) "self",(char *) "style", NULL
29957 };
29958
29959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29961 if (SWIG_arg_fail(1)) SWIG_fail;
29962 {
29963 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29964 if (SWIG_arg_fail(2)) SWIG_fail;
29965 }
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29969
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 {
29974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29975 }
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj;
29984 wxWindow *arg1 = (wxWindow *) 0 ;
29985 wxBackgroundStyle result;
29986 PyObject * obj0 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29997
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 resultobj = SWIG_From_int((result));
30002 return resultobj;
30003 fail:
30004 return NULL;
30005 }
30006
30007
30008 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj;
30010 wxWindow *arg1 = (wxWindow *) 0 ;
30011 bool result;
30012 PyObject * obj0 = 0 ;
30013 char *kwnames[] = {
30014 (char *) "self", NULL
30015 };
30016
30017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30019 if (SWIG_arg_fail(1)) SWIG_fail;
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = (bool)(arg1)->HasTransparentBackground();
30023
30024 wxPyEndAllowThreads(__tstate);
30025 if (PyErr_Occurred()) SWIG_fail;
30026 }
30027 {
30028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30029 }
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj;
30038 wxWindow *arg1 = (wxWindow *) 0 ;
30039 wxCursor *arg2 = 0 ;
30040 bool result;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char *kwnames[] = {
30044 (char *) "self",(char *) "cursor", NULL
30045 };
30046
30047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30049 if (SWIG_arg_fail(1)) SWIG_fail;
30050 {
30051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30052 if (SWIG_arg_fail(2)) SWIG_fail;
30053 if (arg2 == NULL) {
30054 SWIG_null_ref("wxCursor");
30055 }
30056 if (SWIG_arg_fail(2)) SWIG_fail;
30057 }
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30061
30062 wxPyEndAllowThreads(__tstate);
30063 if (PyErr_Occurred()) SWIG_fail;
30064 }
30065 {
30066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30067 }
30068 return resultobj;
30069 fail:
30070 return NULL;
30071 }
30072
30073
30074 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30075 PyObject *resultobj;
30076 wxWindow *arg1 = (wxWindow *) 0 ;
30077 wxCursor result;
30078 PyObject * obj0 = 0 ;
30079 char *kwnames[] = {
30080 (char *) "self", NULL
30081 };
30082
30083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30085 if (SWIG_arg_fail(1)) SWIG_fail;
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (arg1)->GetCursor();
30089
30090 wxPyEndAllowThreads(__tstate);
30091 if (PyErr_Occurred()) SWIG_fail;
30092 }
30093 {
30094 wxCursor * resultptr;
30095 resultptr = new wxCursor((wxCursor &)(result));
30096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30097 }
30098 return resultobj;
30099 fail:
30100 return NULL;
30101 }
30102
30103
30104 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30105 PyObject *resultobj;
30106 wxWindow *arg1 = (wxWindow *) 0 ;
30107 wxFont *arg2 = 0 ;
30108 bool result;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "self",(char *) "font", NULL
30113 };
30114
30115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30117 if (SWIG_arg_fail(1)) SWIG_fail;
30118 {
30119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30120 if (SWIG_arg_fail(2)) SWIG_fail;
30121 if (arg2 == NULL) {
30122 SWIG_null_ref("wxFont");
30123 }
30124 if (SWIG_arg_fail(2)) SWIG_fail;
30125 }
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30129
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 {
30134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30135 }
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxWindow *arg1 = (wxWindow *) 0 ;
30145 wxFont *arg2 = 0 ;
30146 PyObject * obj0 = 0 ;
30147 PyObject * obj1 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self",(char *) "font", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30157 if (SWIG_arg_fail(2)) SWIG_fail;
30158 if (arg2 == NULL) {
30159 SWIG_null_ref("wxFont");
30160 }
30161 if (SWIG_arg_fail(2)) SWIG_fail;
30162 }
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 (arg1)->SetOwnFont((wxFont const &)*arg2);
30166
30167 wxPyEndAllowThreads(__tstate);
30168 if (PyErr_Occurred()) SWIG_fail;
30169 }
30170 Py_INCREF(Py_None); resultobj = Py_None;
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj;
30179 wxWindow *arg1 = (wxWindow *) 0 ;
30180 wxFont result;
30181 PyObject * obj0 = 0 ;
30182 char *kwnames[] = {
30183 (char *) "self", NULL
30184 };
30185
30186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 result = (arg1)->GetFont();
30192
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 {
30197 wxFont * resultptr;
30198 resultptr = new wxFont((wxFont &)(result));
30199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30200 }
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj;
30209 wxWindow *arg1 = (wxWindow *) 0 ;
30210 wxCaret *arg2 = (wxCaret *) 0 ;
30211 PyObject * obj0 = 0 ;
30212 PyObject * obj1 = 0 ;
30213 char *kwnames[] = {
30214 (char *) "self",(char *) "caret", NULL
30215 };
30216
30217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30219 if (SWIG_arg_fail(1)) SWIG_fail;
30220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30221 if (SWIG_arg_fail(2)) SWIG_fail;
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 (arg1)->SetCaret(arg2);
30225
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 Py_INCREF(Py_None); resultobj = Py_None;
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 wxCaret *result;
30240 PyObject * obj0 = 0 ;
30241 char *kwnames[] = {
30242 (char *) "self", NULL
30243 };
30244
30245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30247 if (SWIG_arg_fail(1)) SWIG_fail;
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30263 PyObject *resultobj;
30264 wxWindow *arg1 = (wxWindow *) 0 ;
30265 int result;
30266 PyObject * obj0 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "self", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30273 if (SWIG_arg_fail(1)) SWIG_fail;
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 {
30282 resultobj = SWIG_From_int((int)(result));
30283 }
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30291 PyObject *resultobj;
30292 wxWindow *arg1 = (wxWindow *) 0 ;
30293 int result;
30294 PyObject * obj0 = 0 ;
30295 char *kwnames[] = {
30296 (char *) "self", NULL
30297 };
30298
30299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30301 if (SWIG_arg_fail(1)) SWIG_fail;
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30305
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 {
30310 resultobj = SWIG_From_int((int)(result));
30311 }
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj;
30320 wxWindow *arg1 = (wxWindow *) 0 ;
30321 wxString *arg2 = 0 ;
30322 int *arg3 = (int *) 0 ;
30323 int *arg4 = (int *) 0 ;
30324 bool temp2 = false ;
30325 int temp3 ;
30326 int res3 = 0 ;
30327 int temp4 ;
30328 int res4 = 0 ;
30329 PyObject * obj0 = 0 ;
30330 PyObject * obj1 = 0 ;
30331 char *kwnames[] = {
30332 (char *) "self",(char *) "string", NULL
30333 };
30334
30335 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30336 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30339 if (SWIG_arg_fail(1)) SWIG_fail;
30340 {
30341 arg2 = wxString_in_helper(obj1);
30342 if (arg2 == NULL) SWIG_fail;
30343 temp2 = true;
30344 }
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30348
30349 wxPyEndAllowThreads(__tstate);
30350 if (PyErr_Occurred()) SWIG_fail;
30351 }
30352 Py_INCREF(Py_None); resultobj = Py_None;
30353 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30354 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30355 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30356 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30357 {
30358 if (temp2)
30359 delete arg2;
30360 }
30361 return resultobj;
30362 fail:
30363 {
30364 if (temp2)
30365 delete arg2;
30366 }
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxWindow *arg1 = (wxWindow *) 0 ;
30374 wxString *arg2 = 0 ;
30375 int *arg3 = (int *) 0 ;
30376 int *arg4 = (int *) 0 ;
30377 int *arg5 = (int *) 0 ;
30378 int *arg6 = (int *) 0 ;
30379 wxFont *arg7 = (wxFont *) NULL ;
30380 bool temp2 = false ;
30381 int temp3 ;
30382 int res3 = 0 ;
30383 int temp4 ;
30384 int res4 = 0 ;
30385 int temp5 ;
30386 int res5 = 0 ;
30387 int temp6 ;
30388 int res6 = 0 ;
30389 PyObject * obj0 = 0 ;
30390 PyObject * obj1 = 0 ;
30391 PyObject * obj2 = 0 ;
30392 char *kwnames[] = {
30393 (char *) "self",(char *) "string",(char *) "font", NULL
30394 };
30395
30396 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30397 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30398 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30399 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30402 if (SWIG_arg_fail(1)) SWIG_fail;
30403 {
30404 arg2 = wxString_in_helper(obj1);
30405 if (arg2 == NULL) SWIG_fail;
30406 temp2 = true;
30407 }
30408 if (obj2) {
30409 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30410 if (SWIG_arg_fail(7)) SWIG_fail;
30411 }
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30415
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 Py_INCREF(Py_None); resultobj = Py_None;
30420 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30421 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30422 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30423 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30424 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30425 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30426 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30427 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30428 {
30429 if (temp2)
30430 delete arg2;
30431 }
30432 return resultobj;
30433 fail:
30434 {
30435 if (temp2)
30436 delete arg2;
30437 }
30438 return NULL;
30439 }
30440
30441
30442 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30443 PyObject *resultobj;
30444 wxWindow *arg1 = (wxWindow *) 0 ;
30445 int *arg2 = (int *) 0 ;
30446 int *arg3 = (int *) 0 ;
30447 int temp2 ;
30448 int res2 = 0 ;
30449 int temp3 ;
30450 int res3 = 0 ;
30451 PyObject * obj0 = 0 ;
30452 PyObject * obj1 = 0 ;
30453 PyObject * obj2 = 0 ;
30454 char *kwnames[] = {
30455 (char *) "self",(char *) "x",(char *) "y", NULL
30456 };
30457
30458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30460 if (SWIG_arg_fail(1)) SWIG_fail;
30461 {
30462 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30463 temp2 = SWIG_As_int(obj1);
30464 if (SWIG_arg_fail(2)) SWIG_fail;
30465 arg2 = &temp2;
30466 res2 = SWIG_NEWOBJ;
30467 }
30468 }
30469 {
30470 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30471 temp3 = SWIG_As_int(obj2);
30472 if (SWIG_arg_fail(3)) SWIG_fail;
30473 arg3 = &temp3;
30474 res3 = SWIG_NEWOBJ;
30475 }
30476 }
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30480
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 Py_INCREF(Py_None); resultobj = Py_None;
30485 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30486 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30487 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30488 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj;
30497 wxWindow *arg1 = (wxWindow *) 0 ;
30498 int *arg2 = (int *) 0 ;
30499 int *arg3 = (int *) 0 ;
30500 int temp2 ;
30501 int res2 = 0 ;
30502 int temp3 ;
30503 int res3 = 0 ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 PyObject * obj2 = 0 ;
30507 char *kwnames[] = {
30508 (char *) "self",(char *) "x",(char *) "y", NULL
30509 };
30510
30511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30513 if (SWIG_arg_fail(1)) SWIG_fail;
30514 {
30515 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30516 temp2 = SWIG_As_int(obj1);
30517 if (SWIG_arg_fail(2)) SWIG_fail;
30518 arg2 = &temp2;
30519 res2 = SWIG_NEWOBJ;
30520 }
30521 }
30522 {
30523 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30524 temp3 = SWIG_As_int(obj2);
30525 if (SWIG_arg_fail(3)) SWIG_fail;
30526 arg3 = &temp3;
30527 res3 = SWIG_NEWOBJ;
30528 }
30529 }
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 Py_INCREF(Py_None); resultobj = Py_None;
30538 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30539 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30540 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30541 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj;
30550 wxWindow *arg1 = (wxWindow *) 0 ;
30551 wxPoint *arg2 = 0 ;
30552 wxPoint result;
30553 wxPoint temp2 ;
30554 PyObject * obj0 = 0 ;
30555 PyObject * obj1 = 0 ;
30556 char *kwnames[] = {
30557 (char *) "self",(char *) "pt", NULL
30558 };
30559
30560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30562 if (SWIG_arg_fail(1)) SWIG_fail;
30563 {
30564 arg2 = &temp2;
30565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30566 }
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30570
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 {
30575 wxPoint * resultptr;
30576 resultptr = new wxPoint((wxPoint &)(result));
30577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxPoint *arg2 = 0 ;
30589 wxPoint result;
30590 wxPoint temp2 ;
30591 PyObject * obj0 = 0 ;
30592 PyObject * obj1 = 0 ;
30593 char *kwnames[] = {
30594 (char *) "self",(char *) "pt", NULL
30595 };
30596
30597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30599 if (SWIG_arg_fail(1)) SWIG_fail;
30600 {
30601 arg2 = &temp2;
30602 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30603 }
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30607
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 {
30612 wxPoint * resultptr;
30613 resultptr = new wxPoint((wxPoint &)(result));
30614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30615 }
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30623 PyObject *resultobj;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 int arg2 ;
30626 int arg3 ;
30627 wxHitTest result;
30628 PyObject * obj0 = 0 ;
30629 PyObject * obj1 = 0 ;
30630 PyObject * obj2 = 0 ;
30631 char *kwnames[] = {
30632 (char *) "self",(char *) "x",(char *) "y", NULL
30633 };
30634
30635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30637 if (SWIG_arg_fail(1)) SWIG_fail;
30638 {
30639 arg2 = (int)(SWIG_As_int(obj1));
30640 if (SWIG_arg_fail(2)) SWIG_fail;
30641 }
30642 {
30643 arg3 = (int)(SWIG_As_int(obj2));
30644 if (SWIG_arg_fail(3)) SWIG_fail;
30645 }
30646 {
30647 PyThreadState* __tstate = wxPyBeginAllowThreads();
30648 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30649
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 resultobj = SWIG_From_int((result));
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxPoint *arg2 = 0 ;
30664 wxHitTest result;
30665 wxPoint temp2 ;
30666 PyObject * obj0 = 0 ;
30667 PyObject * obj1 = 0 ;
30668 char *kwnames[] = {
30669 (char *) "self",(char *) "pt", NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30674 if (SWIG_arg_fail(1)) SWIG_fail;
30675 {
30676 arg2 = &temp2;
30677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30678 }
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30682
30683 wxPyEndAllowThreads(__tstate);
30684 if (PyErr_Occurred()) SWIG_fail;
30685 }
30686 resultobj = SWIG_From_int((result));
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30694 PyObject *resultobj;
30695 wxWindow *arg1 = (wxWindow *) 0 ;
30696 long arg2 ;
30697 wxBorder result;
30698 PyObject * obj0 = 0 ;
30699 PyObject * obj1 = 0 ;
30700
30701 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30703 if (SWIG_arg_fail(1)) SWIG_fail;
30704 {
30705 arg2 = (long)(SWIG_As_long(obj1));
30706 if (SWIG_arg_fail(2)) SWIG_fail;
30707 }
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 resultobj = SWIG_From_int((result));
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30723 PyObject *resultobj;
30724 wxWindow *arg1 = (wxWindow *) 0 ;
30725 wxBorder result;
30726 PyObject * obj0 = 0 ;
30727
30728 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30734
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 resultobj = SWIG_From_int((result));
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30746 int argc;
30747 PyObject *argv[3];
30748 int ii;
30749
30750 argc = PyObject_Length(args);
30751 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30752 argv[ii] = PyTuple_GetItem(args,ii);
30753 }
30754 if (argc == 1) {
30755 int _v;
30756 {
30757 void *ptr;
30758 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30759 _v = 0;
30760 PyErr_Clear();
30761 } else {
30762 _v = 1;
30763 }
30764 }
30765 if (_v) {
30766 return _wrap_Window_GetBorder__SWIG_1(self,args);
30767 }
30768 }
30769 if (argc == 2) {
30770 int _v;
30771 {
30772 void *ptr;
30773 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30774 _v = 0;
30775 PyErr_Clear();
30776 } else {
30777 _v = 1;
30778 }
30779 }
30780 if (_v) {
30781 _v = SWIG_Check_long(argv[1]);
30782 if (_v) {
30783 return _wrap_Window_GetBorder__SWIG_0(self,args);
30784 }
30785 }
30786 }
30787
30788 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30789 return NULL;
30790 }
30791
30792
30793 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30794 PyObject *resultobj;
30795 wxWindow *arg1 = (wxWindow *) 0 ;
30796 long arg2 = (long) wxUPDATE_UI_NONE ;
30797 PyObject * obj0 = 0 ;
30798 PyObject * obj1 = 0 ;
30799 char *kwnames[] = {
30800 (char *) "self",(char *) "flags", NULL
30801 };
30802
30803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30805 if (SWIG_arg_fail(1)) SWIG_fail;
30806 if (obj1) {
30807 {
30808 arg2 = (long)(SWIG_As_long(obj1));
30809 if (SWIG_arg_fail(2)) SWIG_fail;
30810 }
30811 }
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 (arg1)->UpdateWindowUI(arg2);
30815
30816 wxPyEndAllowThreads(__tstate);
30817 if (PyErr_Occurred()) SWIG_fail;
30818 }
30819 Py_INCREF(Py_None); resultobj = Py_None;
30820 return resultobj;
30821 fail:
30822 return NULL;
30823 }
30824
30825
30826 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30827 PyObject *resultobj;
30828 wxWindow *arg1 = (wxWindow *) 0 ;
30829 wxMenu *arg2 = (wxMenu *) 0 ;
30830 int arg3 = (int) -1 ;
30831 int arg4 = (int) -1 ;
30832 bool result;
30833 PyObject * obj0 = 0 ;
30834 PyObject * obj1 = 0 ;
30835 PyObject * obj2 = 0 ;
30836 PyObject * obj3 = 0 ;
30837 char *kwnames[] = {
30838 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30839 };
30840
30841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30843 if (SWIG_arg_fail(1)) SWIG_fail;
30844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30845 if (SWIG_arg_fail(2)) SWIG_fail;
30846 if (obj2) {
30847 {
30848 arg3 = (int)(SWIG_As_int(obj2));
30849 if (SWIG_arg_fail(3)) SWIG_fail;
30850 }
30851 }
30852 if (obj3) {
30853 {
30854 arg4 = (int)(SWIG_As_int(obj3));
30855 if (SWIG_arg_fail(4)) SWIG_fail;
30856 }
30857 }
30858 {
30859 PyThreadState* __tstate = wxPyBeginAllowThreads();
30860 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30861
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 {
30866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 wxMenu *arg2 = (wxMenu *) 0 ;
30878 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30879 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30880 bool result;
30881 wxPoint temp3 ;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 PyObject * obj2 = 0 ;
30885 char *kwnames[] = {
30886 (char *) "self",(char *) "menu",(char *) "pos", NULL
30887 };
30888
30889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30891 if (SWIG_arg_fail(1)) SWIG_fail;
30892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30893 if (SWIG_arg_fail(2)) SWIG_fail;
30894 if (obj2) {
30895 {
30896 arg3 = &temp3;
30897 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30898 }
30899 }
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30903
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 {
30908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30909 }
30910 return resultobj;
30911 fail:
30912 return NULL;
30913 }
30914
30915
30916 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30917 PyObject *resultobj;
30918 wxWindow *arg1 = (wxWindow *) 0 ;
30919 long result;
30920 PyObject * obj0 = 0 ;
30921 char *kwnames[] = {
30922 (char *) "self", NULL
30923 };
30924
30925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30927 if (SWIG_arg_fail(1)) SWIG_fail;
30928 {
30929 PyThreadState* __tstate = wxPyBeginAllowThreads();
30930 result = (long)wxWindow_GetHandle(arg1);
30931
30932 wxPyEndAllowThreads(__tstate);
30933 if (PyErr_Occurred()) SWIG_fail;
30934 }
30935 {
30936 resultobj = SWIG_From_long((long)(result));
30937 }
30938 return resultobj;
30939 fail:
30940 return NULL;
30941 }
30942
30943
30944 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30945 PyObject *resultobj;
30946 wxWindow *arg1 = (wxWindow *) 0 ;
30947 long arg2 ;
30948 PyObject * obj0 = 0 ;
30949 PyObject * obj1 = 0 ;
30950 char *kwnames[] = {
30951 (char *) "self",(char *) "handle", NULL
30952 };
30953
30954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30956 if (SWIG_arg_fail(1)) SWIG_fail;
30957 {
30958 arg2 = (long)(SWIG_As_long(obj1));
30959 if (SWIG_arg_fail(2)) SWIG_fail;
30960 }
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 wxWindow_AssociateHandle(arg1,arg2);
30964
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 Py_INCREF(Py_None); resultobj = Py_None;
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30976 PyObject *resultobj;
30977 wxWindow *arg1 = (wxWindow *) 0 ;
30978 PyObject * obj0 = 0 ;
30979 char *kwnames[] = {
30980 (char *) "self", NULL
30981 };
30982
30983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30985 if (SWIG_arg_fail(1)) SWIG_fail;
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 (arg1)->DissociateHandle();
30989
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 Py_INCREF(Py_None); resultobj = Py_None;
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31001 PyObject *resultobj;
31002 wxWindow *arg1 = (wxWindow *) 0 ;
31003 wxPaintEvent *arg2 = 0 ;
31004 PyObject * obj0 = 0 ;
31005 PyObject * obj1 = 0 ;
31006 char *kwnames[] = {
31007 (char *) "self",(char *) "event", NULL
31008 };
31009
31010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31012 if (SWIG_arg_fail(1)) SWIG_fail;
31013 {
31014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31015 if (SWIG_arg_fail(2)) SWIG_fail;
31016 if (arg2 == NULL) {
31017 SWIG_null_ref("wxPaintEvent");
31018 }
31019 if (SWIG_arg_fail(2)) SWIG_fail;
31020 }
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 (arg1)->OnPaint(*arg2);
31024
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 Py_INCREF(Py_None); resultobj = Py_None;
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj;
31037 wxWindow *arg1 = (wxWindow *) 0 ;
31038 int arg2 ;
31039 bool result;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 char *kwnames[] = {
31043 (char *) "self",(char *) "orient", NULL
31044 };
31045
31046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31048 if (SWIG_arg_fail(1)) SWIG_fail;
31049 {
31050 arg2 = (int)(SWIG_As_int(obj1));
31051 if (SWIG_arg_fail(2)) SWIG_fail;
31052 }
31053 {
31054 PyThreadState* __tstate = wxPyBeginAllowThreads();
31055 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31056
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 {
31061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31062 }
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31070 PyObject *resultobj;
31071 wxWindow *arg1 = (wxWindow *) 0 ;
31072 int arg2 ;
31073 int arg3 ;
31074 int arg4 ;
31075 int arg5 ;
31076 bool arg6 = (bool) true ;
31077 PyObject * obj0 = 0 ;
31078 PyObject * obj1 = 0 ;
31079 PyObject * obj2 = 0 ;
31080 PyObject * obj3 = 0 ;
31081 PyObject * obj4 = 0 ;
31082 PyObject * obj5 = 0 ;
31083 char *kwnames[] = {
31084 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31085 };
31086
31087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31089 if (SWIG_arg_fail(1)) SWIG_fail;
31090 {
31091 arg2 = (int)(SWIG_As_int(obj1));
31092 if (SWIG_arg_fail(2)) SWIG_fail;
31093 }
31094 {
31095 arg3 = (int)(SWIG_As_int(obj2));
31096 if (SWIG_arg_fail(3)) SWIG_fail;
31097 }
31098 {
31099 arg4 = (int)(SWIG_As_int(obj3));
31100 if (SWIG_arg_fail(4)) SWIG_fail;
31101 }
31102 {
31103 arg5 = (int)(SWIG_As_int(obj4));
31104 if (SWIG_arg_fail(5)) SWIG_fail;
31105 }
31106 if (obj5) {
31107 {
31108 arg6 = (bool)(SWIG_As_bool(obj5));
31109 if (SWIG_arg_fail(6)) SWIG_fail;
31110 }
31111 }
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31115
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 Py_INCREF(Py_None); resultobj = Py_None;
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 int arg2 ;
31130 int arg3 ;
31131 bool arg4 = (bool) true ;
31132 PyObject * obj0 = 0 ;
31133 PyObject * obj1 = 0 ;
31134 PyObject * obj2 = 0 ;
31135 PyObject * obj3 = 0 ;
31136 char *kwnames[] = {
31137 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31138 };
31139
31140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31142 if (SWIG_arg_fail(1)) SWIG_fail;
31143 {
31144 arg2 = (int)(SWIG_As_int(obj1));
31145 if (SWIG_arg_fail(2)) SWIG_fail;
31146 }
31147 {
31148 arg3 = (int)(SWIG_As_int(obj2));
31149 if (SWIG_arg_fail(3)) SWIG_fail;
31150 }
31151 if (obj3) {
31152 {
31153 arg4 = (bool)(SWIG_As_bool(obj3));
31154 if (SWIG_arg_fail(4)) SWIG_fail;
31155 }
31156 }
31157 {
31158 PyThreadState* __tstate = wxPyBeginAllowThreads();
31159 (arg1)->SetScrollPos(arg2,arg3,arg4);
31160
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 Py_INCREF(Py_None); resultobj = Py_None;
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj;
31173 wxWindow *arg1 = (wxWindow *) 0 ;
31174 int arg2 ;
31175 int result;
31176 PyObject * obj0 = 0 ;
31177 PyObject * obj1 = 0 ;
31178 char *kwnames[] = {
31179 (char *) "self",(char *) "orientation", NULL
31180 };
31181
31182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31184 if (SWIG_arg_fail(1)) SWIG_fail;
31185 {
31186 arg2 = (int)(SWIG_As_int(obj1));
31187 if (SWIG_arg_fail(2)) SWIG_fail;
31188 }
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31192
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 {
31197 resultobj = SWIG_From_int((int)(result));
31198 }
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj;
31207 wxWindow *arg1 = (wxWindow *) 0 ;
31208 int arg2 ;
31209 int result;
31210 PyObject * obj0 = 0 ;
31211 PyObject * obj1 = 0 ;
31212 char *kwnames[] = {
31213 (char *) "self",(char *) "orientation", NULL
31214 };
31215
31216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31218 if (SWIG_arg_fail(1)) SWIG_fail;
31219 {
31220 arg2 = (int)(SWIG_As_int(obj1));
31221 if (SWIG_arg_fail(2)) SWIG_fail;
31222 }
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 {
31231 resultobj = SWIG_From_int((int)(result));
31232 }
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31240 PyObject *resultobj;
31241 wxWindow *arg1 = (wxWindow *) 0 ;
31242 int arg2 ;
31243 int result;
31244 PyObject * obj0 = 0 ;
31245 PyObject * obj1 = 0 ;
31246 char *kwnames[] = {
31247 (char *) "self",(char *) "orientation", NULL
31248 };
31249
31250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31252 if (SWIG_arg_fail(1)) SWIG_fail;
31253 {
31254 arg2 = (int)(SWIG_As_int(obj1));
31255 if (SWIG_arg_fail(2)) SWIG_fail;
31256 }
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31260
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 {
31265 resultobj = SWIG_From_int((int)(result));
31266 }
31267 return resultobj;
31268 fail:
31269 return NULL;
31270 }
31271
31272
31273 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31274 PyObject *resultobj;
31275 wxWindow *arg1 = (wxWindow *) 0 ;
31276 int arg2 ;
31277 int arg3 ;
31278 wxRect *arg4 = (wxRect *) NULL ;
31279 PyObject * obj0 = 0 ;
31280 PyObject * obj1 = 0 ;
31281 PyObject * obj2 = 0 ;
31282 PyObject * obj3 = 0 ;
31283 char *kwnames[] = {
31284 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31285 };
31286
31287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31289 if (SWIG_arg_fail(1)) SWIG_fail;
31290 {
31291 arg2 = (int)(SWIG_As_int(obj1));
31292 if (SWIG_arg_fail(2)) SWIG_fail;
31293 }
31294 {
31295 arg3 = (int)(SWIG_As_int(obj2));
31296 if (SWIG_arg_fail(3)) SWIG_fail;
31297 }
31298 if (obj3) {
31299 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31300 if (SWIG_arg_fail(4)) SWIG_fail;
31301 }
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31305
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 Py_INCREF(Py_None); resultobj = Py_None;
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31317 PyObject *resultobj;
31318 wxWindow *arg1 = (wxWindow *) 0 ;
31319 int arg2 ;
31320 bool result;
31321 PyObject * obj0 = 0 ;
31322 PyObject * obj1 = 0 ;
31323 char *kwnames[] = {
31324 (char *) "self",(char *) "lines", NULL
31325 };
31326
31327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31329 if (SWIG_arg_fail(1)) SWIG_fail;
31330 {
31331 arg2 = (int)(SWIG_As_int(obj1));
31332 if (SWIG_arg_fail(2)) SWIG_fail;
31333 }
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = (bool)(arg1)->ScrollLines(arg2);
31337
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 {
31342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31343 }
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 int arg2 ;
31354 bool result;
31355 PyObject * obj0 = 0 ;
31356 PyObject * obj1 = 0 ;
31357 char *kwnames[] = {
31358 (char *) "self",(char *) "pages", NULL
31359 };
31360
31361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31363 if (SWIG_arg_fail(1)) SWIG_fail;
31364 {
31365 arg2 = (int)(SWIG_As_int(obj1));
31366 if (SWIG_arg_fail(2)) SWIG_fail;
31367 }
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = (bool)(arg1)->ScrollPages(arg2);
31371
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 {
31376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31377 }
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31385 PyObject *resultobj;
31386 wxWindow *arg1 = (wxWindow *) 0 ;
31387 bool result;
31388 PyObject * obj0 = 0 ;
31389 char *kwnames[] = {
31390 (char *) "self", NULL
31391 };
31392
31393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31395 if (SWIG_arg_fail(1)) SWIG_fail;
31396 {
31397 PyThreadState* __tstate = wxPyBeginAllowThreads();
31398 result = (bool)(arg1)->LineUp();
31399
31400 wxPyEndAllowThreads(__tstate);
31401 if (PyErr_Occurred()) SWIG_fail;
31402 }
31403 {
31404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31405 }
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 bool result;
31416 PyObject * obj0 = 0 ;
31417 char *kwnames[] = {
31418 (char *) "self", NULL
31419 };
31420
31421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31423 if (SWIG_arg_fail(1)) SWIG_fail;
31424 {
31425 PyThreadState* __tstate = wxPyBeginAllowThreads();
31426 result = (bool)(arg1)->LineDown();
31427
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 {
31432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31433 }
31434 return resultobj;
31435 fail:
31436 return NULL;
31437 }
31438
31439
31440 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31441 PyObject *resultobj;
31442 wxWindow *arg1 = (wxWindow *) 0 ;
31443 bool result;
31444 PyObject * obj0 = 0 ;
31445 char *kwnames[] = {
31446 (char *) "self", NULL
31447 };
31448
31449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31451 if (SWIG_arg_fail(1)) SWIG_fail;
31452 {
31453 PyThreadState* __tstate = wxPyBeginAllowThreads();
31454 result = (bool)(arg1)->PageUp();
31455
31456 wxPyEndAllowThreads(__tstate);
31457 if (PyErr_Occurred()) SWIG_fail;
31458 }
31459 {
31460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31461 }
31462 return resultobj;
31463 fail:
31464 return NULL;
31465 }
31466
31467
31468 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31469 PyObject *resultobj;
31470 wxWindow *arg1 = (wxWindow *) 0 ;
31471 bool result;
31472 PyObject * obj0 = 0 ;
31473 char *kwnames[] = {
31474 (char *) "self", NULL
31475 };
31476
31477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31479 if (SWIG_arg_fail(1)) SWIG_fail;
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 result = (bool)(arg1)->PageDown();
31483
31484 wxPyEndAllowThreads(__tstate);
31485 if (PyErr_Occurred()) SWIG_fail;
31486 }
31487 {
31488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31489 }
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31497 PyObject *resultobj;
31498 wxWindow *arg1 = (wxWindow *) 0 ;
31499 wxString *arg2 = 0 ;
31500 bool temp2 = false ;
31501 PyObject * obj0 = 0 ;
31502 PyObject * obj1 = 0 ;
31503 char *kwnames[] = {
31504 (char *) "self",(char *) "text", NULL
31505 };
31506
31507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31509 if (SWIG_arg_fail(1)) SWIG_fail;
31510 {
31511 arg2 = wxString_in_helper(obj1);
31512 if (arg2 == NULL) SWIG_fail;
31513 temp2 = true;
31514 }
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 (arg1)->SetHelpText((wxString const &)*arg2);
31518
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 Py_INCREF(Py_None); resultobj = Py_None;
31523 {
31524 if (temp2)
31525 delete arg2;
31526 }
31527 return resultobj;
31528 fail:
31529 {
31530 if (temp2)
31531 delete arg2;
31532 }
31533 return NULL;
31534 }
31535
31536
31537 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31538 PyObject *resultobj;
31539 wxWindow *arg1 = (wxWindow *) 0 ;
31540 wxString *arg2 = 0 ;
31541 bool temp2 = false ;
31542 PyObject * obj0 = 0 ;
31543 PyObject * obj1 = 0 ;
31544 char *kwnames[] = {
31545 (char *) "self",(char *) "text", NULL
31546 };
31547
31548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31550 if (SWIG_arg_fail(1)) SWIG_fail;
31551 {
31552 arg2 = wxString_in_helper(obj1);
31553 if (arg2 == NULL) SWIG_fail;
31554 temp2 = true;
31555 }
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31559
31560 wxPyEndAllowThreads(__tstate);
31561 if (PyErr_Occurred()) SWIG_fail;
31562 }
31563 Py_INCREF(Py_None); resultobj = Py_None;
31564 {
31565 if (temp2)
31566 delete arg2;
31567 }
31568 return resultobj;
31569 fail:
31570 {
31571 if (temp2)
31572 delete arg2;
31573 }
31574 return NULL;
31575 }
31576
31577
31578 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31579 PyObject *resultobj;
31580 wxWindow *arg1 = (wxWindow *) 0 ;
31581 wxString result;
31582 PyObject * obj0 = 0 ;
31583 char *kwnames[] = {
31584 (char *) "self", NULL
31585 };
31586
31587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31589 if (SWIG_arg_fail(1)) SWIG_fail;
31590 {
31591 PyThreadState* __tstate = wxPyBeginAllowThreads();
31592 result = ((wxWindow const *)arg1)->GetHelpText();
31593
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 {
31598 #if wxUSE_UNICODE
31599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31600 #else
31601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31602 #endif
31603 }
31604 return resultobj;
31605 fail:
31606 return NULL;
31607 }
31608
31609
31610 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31611 PyObject *resultobj;
31612 wxWindow *arg1 = (wxWindow *) 0 ;
31613 wxString *arg2 = 0 ;
31614 bool temp2 = false ;
31615 PyObject * obj0 = 0 ;
31616 PyObject * obj1 = 0 ;
31617 char *kwnames[] = {
31618 (char *) "self",(char *) "tip", NULL
31619 };
31620
31621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31623 if (SWIG_arg_fail(1)) SWIG_fail;
31624 {
31625 arg2 = wxString_in_helper(obj1);
31626 if (arg2 == NULL) SWIG_fail;
31627 temp2 = true;
31628 }
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 (arg1)->SetToolTip((wxString const &)*arg2);
31632
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 Py_INCREF(Py_None); resultobj = Py_None;
31637 {
31638 if (temp2)
31639 delete arg2;
31640 }
31641 return resultobj;
31642 fail:
31643 {
31644 if (temp2)
31645 delete arg2;
31646 }
31647 return NULL;
31648 }
31649
31650
31651 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31652 PyObject *resultobj;
31653 wxWindow *arg1 = (wxWindow *) 0 ;
31654 wxToolTip *arg2 = (wxToolTip *) 0 ;
31655 PyObject * obj0 = 0 ;
31656 PyObject * obj1 = 0 ;
31657 char *kwnames[] = {
31658 (char *) "self",(char *) "tip", NULL
31659 };
31660
31661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31663 if (SWIG_arg_fail(1)) SWIG_fail;
31664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31665 if (SWIG_arg_fail(2)) SWIG_fail;
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 (arg1)->SetToolTip(arg2);
31669
31670 wxPyEndAllowThreads(__tstate);
31671 if (PyErr_Occurred()) SWIG_fail;
31672 }
31673 Py_INCREF(Py_None); resultobj = Py_None;
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj;
31682 wxWindow *arg1 = (wxWindow *) 0 ;
31683 wxToolTip *result;
31684 PyObject * obj0 = 0 ;
31685 char *kwnames[] = {
31686 (char *) "self", NULL
31687 };
31688
31689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31691 if (SWIG_arg_fail(1)) SWIG_fail;
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31695
31696 wxPyEndAllowThreads(__tstate);
31697 if (PyErr_Occurred()) SWIG_fail;
31698 }
31699 {
31700 resultobj = wxPyMake_wxObject(result, 0);
31701 }
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31709 PyObject *resultobj;
31710 wxWindow *arg1 = (wxWindow *) 0 ;
31711 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31712 PyObject * obj0 = 0 ;
31713 PyObject * obj1 = 0 ;
31714 char *kwnames[] = {
31715 (char *) "self",(char *) "dropTarget", NULL
31716 };
31717
31718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31720 if (SWIG_arg_fail(1)) SWIG_fail;
31721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31722 if (SWIG_arg_fail(2)) SWIG_fail;
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 (arg1)->SetDropTarget(arg2);
31726
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 Py_INCREF(Py_None); resultobj = Py_None;
31731 return resultobj;
31732 fail:
31733 return NULL;
31734 }
31735
31736
31737 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31738 PyObject *resultobj;
31739 wxWindow *arg1 = (wxWindow *) 0 ;
31740 wxPyDropTarget *result;
31741 PyObject * obj0 = 0 ;
31742 char *kwnames[] = {
31743 (char *) "self", NULL
31744 };
31745
31746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31748 if (SWIG_arg_fail(1)) SWIG_fail;
31749 {
31750 PyThreadState* __tstate = wxPyBeginAllowThreads();
31751 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31752
31753 wxPyEndAllowThreads(__tstate);
31754 if (PyErr_Occurred()) SWIG_fail;
31755 }
31756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj;
31765 wxWindow *arg1 = (wxWindow *) 0 ;
31766 bool arg2 ;
31767 PyObject * obj0 = 0 ;
31768 PyObject * obj1 = 0 ;
31769 char *kwnames[] = {
31770 (char *) "self",(char *) "accept", NULL
31771 };
31772
31773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31775 if (SWIG_arg_fail(1)) SWIG_fail;
31776 {
31777 arg2 = (bool)(SWIG_As_bool(obj1));
31778 if (SWIG_arg_fail(2)) SWIG_fail;
31779 }
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 (arg1)->DragAcceptFiles(arg2);
31783
31784 wxPyEndAllowThreads(__tstate);
31785 if (PyErr_Occurred()) SWIG_fail;
31786 }
31787 Py_INCREF(Py_None); resultobj = Py_None;
31788 return resultobj;
31789 fail:
31790 return NULL;
31791 }
31792
31793
31794 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj;
31796 wxWindow *arg1 = (wxWindow *) 0 ;
31797 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31798 PyObject * obj0 = 0 ;
31799 PyObject * obj1 = 0 ;
31800 char *kwnames[] = {
31801 (char *) "self",(char *) "constraints", NULL
31802 };
31803
31804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31806 if (SWIG_arg_fail(1)) SWIG_fail;
31807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(2)) SWIG_fail;
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 (arg1)->SetConstraints(arg2);
31812
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 Py_INCREF(Py_None); resultobj = Py_None;
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj;
31825 wxWindow *arg1 = (wxWindow *) 0 ;
31826 wxLayoutConstraints *result;
31827 PyObject * obj0 = 0 ;
31828 char *kwnames[] = {
31829 (char *) "self", NULL
31830 };
31831
31832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31834 if (SWIG_arg_fail(1)) SWIG_fail;
31835 {
31836 PyThreadState* __tstate = wxPyBeginAllowThreads();
31837 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31838
31839 wxPyEndAllowThreads(__tstate);
31840 if (PyErr_Occurred()) SWIG_fail;
31841 }
31842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj;
31851 wxWindow *arg1 = (wxWindow *) 0 ;
31852 bool arg2 ;
31853 PyObject * obj0 = 0 ;
31854 PyObject * obj1 = 0 ;
31855 char *kwnames[] = {
31856 (char *) "self",(char *) "autoLayout", NULL
31857 };
31858
31859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31861 if (SWIG_arg_fail(1)) SWIG_fail;
31862 {
31863 arg2 = (bool)(SWIG_As_bool(obj1));
31864 if (SWIG_arg_fail(2)) SWIG_fail;
31865 }
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 (arg1)->SetAutoLayout(arg2);
31869
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 Py_INCREF(Py_None); resultobj = Py_None;
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 bool result;
31884 PyObject * obj0 = 0 ;
31885 char *kwnames[] = {
31886 (char *) "self", NULL
31887 };
31888
31889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31891 if (SWIG_arg_fail(1)) SWIG_fail;
31892 {
31893 PyThreadState* __tstate = wxPyBeginAllowThreads();
31894 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31895
31896 wxPyEndAllowThreads(__tstate);
31897 if (PyErr_Occurred()) SWIG_fail;
31898 }
31899 {
31900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31901 }
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31909 PyObject *resultobj;
31910 wxWindow *arg1 = (wxWindow *) 0 ;
31911 bool result;
31912 PyObject * obj0 = 0 ;
31913 char *kwnames[] = {
31914 (char *) "self", NULL
31915 };
31916
31917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) 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 {
31921 PyThreadState* __tstate = wxPyBeginAllowThreads();
31922 result = (bool)(arg1)->Layout();
31923
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 {
31928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31929 }
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31937 PyObject *resultobj;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 wxSizer *arg2 = (wxSizer *) 0 ;
31940 bool arg3 = (bool) true ;
31941 PyObject * obj0 = 0 ;
31942 PyObject * obj1 = 0 ;
31943 PyObject * obj2 = 0 ;
31944 char *kwnames[] = {
31945 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31946 };
31947
31948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31950 if (SWIG_arg_fail(1)) SWIG_fail;
31951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31952 if (SWIG_arg_fail(2)) SWIG_fail;
31953 if (obj2) {
31954 {
31955 arg3 = (bool)(SWIG_As_bool(obj2));
31956 if (SWIG_arg_fail(3)) SWIG_fail;
31957 }
31958 }
31959 {
31960 PyThreadState* __tstate = wxPyBeginAllowThreads();
31961 (arg1)->SetSizer(arg2,arg3);
31962
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 Py_INCREF(Py_None); resultobj = Py_None;
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 wxSizer *arg2 = (wxSizer *) 0 ;
31977 bool arg3 = (bool) true ;
31978 PyObject * obj0 = 0 ;
31979 PyObject * obj1 = 0 ;
31980 PyObject * obj2 = 0 ;
31981 char *kwnames[] = {
31982 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31983 };
31984
31985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31987 if (SWIG_arg_fail(1)) SWIG_fail;
31988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31989 if (SWIG_arg_fail(2)) SWIG_fail;
31990 if (obj2) {
31991 {
31992 arg3 = (bool)(SWIG_As_bool(obj2));
31993 if (SWIG_arg_fail(3)) SWIG_fail;
31994 }
31995 }
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 (arg1)->SetSizerAndFit(arg2,arg3);
31999
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 Py_INCREF(Py_None); resultobj = Py_None;
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32011 PyObject *resultobj;
32012 wxWindow *arg1 = (wxWindow *) 0 ;
32013 wxSizer *result;
32014 PyObject * obj0 = 0 ;
32015 char *kwnames[] = {
32016 (char *) "self", NULL
32017 };
32018
32019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32021 if (SWIG_arg_fail(1)) SWIG_fail;
32022 {
32023 PyThreadState* __tstate = wxPyBeginAllowThreads();
32024 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32025
32026 wxPyEndAllowThreads(__tstate);
32027 if (PyErr_Occurred()) SWIG_fail;
32028 }
32029 {
32030 resultobj = wxPyMake_wxObject(result, 0);
32031 }
32032 return resultobj;
32033 fail:
32034 return NULL;
32035 }
32036
32037
32038 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32039 PyObject *resultobj;
32040 wxWindow *arg1 = (wxWindow *) 0 ;
32041 wxSizer *arg2 = (wxSizer *) 0 ;
32042 PyObject * obj0 = 0 ;
32043 PyObject * obj1 = 0 ;
32044 char *kwnames[] = {
32045 (char *) "self",(char *) "sizer", NULL
32046 };
32047
32048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32050 if (SWIG_arg_fail(1)) SWIG_fail;
32051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(2)) SWIG_fail;
32053 {
32054 PyThreadState* __tstate = wxPyBeginAllowThreads();
32055 (arg1)->SetContainingSizer(arg2);
32056
32057 wxPyEndAllowThreads(__tstate);
32058 if (PyErr_Occurred()) SWIG_fail;
32059 }
32060 Py_INCREF(Py_None); resultobj = Py_None;
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj;
32069 wxWindow *arg1 = (wxWindow *) 0 ;
32070 wxSizer *result;
32071 PyObject * obj0 = 0 ;
32072 char *kwnames[] = {
32073 (char *) "self", NULL
32074 };
32075
32076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32078 if (SWIG_arg_fail(1)) SWIG_fail;
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32082
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 {
32087 resultobj = wxPyMake_wxObject(result, 0);
32088 }
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj;
32097 wxWindow *arg1 = (wxWindow *) 0 ;
32098 PyObject * obj0 = 0 ;
32099 char *kwnames[] = {
32100 (char *) "self", NULL
32101 };
32102
32103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32105 if (SWIG_arg_fail(1)) SWIG_fail;
32106 {
32107 PyThreadState* __tstate = wxPyBeginAllowThreads();
32108 (arg1)->InheritAttributes();
32109
32110 wxPyEndAllowThreads(__tstate);
32111 if (PyErr_Occurred()) SWIG_fail;
32112 }
32113 Py_INCREF(Py_None); resultobj = Py_None;
32114 return resultobj;
32115 fail:
32116 return NULL;
32117 }
32118
32119
32120 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj;
32122 wxWindow *arg1 = (wxWindow *) 0 ;
32123 bool result;
32124 PyObject * obj0 = 0 ;
32125 char *kwnames[] = {
32126 (char *) "self", NULL
32127 };
32128
32129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32131 if (SWIG_arg_fail(1)) SWIG_fail;
32132 {
32133 PyThreadState* __tstate = wxPyBeginAllowThreads();
32134 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32135
32136 wxPyEndAllowThreads(__tstate);
32137 if (PyErr_Occurred()) SWIG_fail;
32138 }
32139 {
32140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32141 }
32142 return resultobj;
32143 fail:
32144 return NULL;
32145 }
32146
32147
32148 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32149 PyObject *obj;
32150 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32151 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32152 Py_INCREF(obj);
32153 return Py_BuildValue((char *)"");
32154 }
32155 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32156 PyObject *resultobj;
32157 long arg1 ;
32158 wxWindow *arg2 = (wxWindow *) NULL ;
32159 wxWindow *result;
32160 PyObject * obj0 = 0 ;
32161 PyObject * obj1 = 0 ;
32162 char *kwnames[] = {
32163 (char *) "id",(char *) "parent", NULL
32164 };
32165
32166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32167 {
32168 arg1 = (long)(SWIG_As_long(obj0));
32169 if (SWIG_arg_fail(1)) SWIG_fail;
32170 }
32171 if (obj1) {
32172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32173 if (SWIG_arg_fail(2)) SWIG_fail;
32174 }
32175 {
32176 if (!wxPyCheckForApp()) SWIG_fail;
32177 PyThreadState* __tstate = wxPyBeginAllowThreads();
32178 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32179
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 {
32184 resultobj = wxPyMake_wxObject(result, 0);
32185 }
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32193 PyObject *resultobj;
32194 wxString *arg1 = 0 ;
32195 wxWindow *arg2 = (wxWindow *) NULL ;
32196 wxWindow *result;
32197 bool temp1 = false ;
32198 PyObject * obj0 = 0 ;
32199 PyObject * obj1 = 0 ;
32200 char *kwnames[] = {
32201 (char *) "name",(char *) "parent", NULL
32202 };
32203
32204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32205 {
32206 arg1 = wxString_in_helper(obj0);
32207 if (arg1 == NULL) SWIG_fail;
32208 temp1 = true;
32209 }
32210 if (obj1) {
32211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32212 if (SWIG_arg_fail(2)) SWIG_fail;
32213 }
32214 {
32215 if (!wxPyCheckForApp()) SWIG_fail;
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32218
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = wxPyMake_wxObject(result, 0);
32224 }
32225 {
32226 if (temp1)
32227 delete arg1;
32228 }
32229 return resultobj;
32230 fail:
32231 {
32232 if (temp1)
32233 delete arg1;
32234 }
32235 return NULL;
32236 }
32237
32238
32239 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32240 PyObject *resultobj;
32241 wxString *arg1 = 0 ;
32242 wxWindow *arg2 = (wxWindow *) NULL ;
32243 wxWindow *result;
32244 bool temp1 = false ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char *kwnames[] = {
32248 (char *) "label",(char *) "parent", NULL
32249 };
32250
32251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32252 {
32253 arg1 = wxString_in_helper(obj0);
32254 if (arg1 == NULL) SWIG_fail;
32255 temp1 = true;
32256 }
32257 if (obj1) {
32258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32259 if (SWIG_arg_fail(2)) SWIG_fail;
32260 }
32261 {
32262 if (!wxPyCheckForApp()) SWIG_fail;
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32265
32266 wxPyEndAllowThreads(__tstate);
32267 if (PyErr_Occurred()) SWIG_fail;
32268 }
32269 {
32270 resultobj = wxPyMake_wxObject(result, 0);
32271 }
32272 {
32273 if (temp1)
32274 delete arg1;
32275 }
32276 return resultobj;
32277 fail:
32278 {
32279 if (temp1)
32280 delete arg1;
32281 }
32282 return NULL;
32283 }
32284
32285
32286 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj;
32288 wxWindow *arg1 = (wxWindow *) 0 ;
32289 unsigned long arg2 ;
32290 wxWindow *result;
32291 PyObject * obj0 = 0 ;
32292 PyObject * obj1 = 0 ;
32293 char *kwnames[] = {
32294 (char *) "parent",(char *) "_hWnd", NULL
32295 };
32296
32297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32299 if (SWIG_arg_fail(1)) SWIG_fail;
32300 {
32301 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32302 if (SWIG_arg_fail(2)) SWIG_fail;
32303 }
32304 {
32305 PyThreadState* __tstate = wxPyBeginAllowThreads();
32306 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32307
32308 wxPyEndAllowThreads(__tstate);
32309 if (PyErr_Occurred()) SWIG_fail;
32310 }
32311 {
32312 resultobj = wxPyMake_wxObject(result, 0);
32313 }
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32321 PyObject *resultobj;
32322 PyObject *result;
32323 char *kwnames[] = {
32324 NULL
32325 };
32326
32327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (PyObject *)GetTopLevelWindows();
32331
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = result;
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32343 PyObject *resultobj;
32344 wxValidator *result;
32345 char *kwnames[] = {
32346 NULL
32347 };
32348
32349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32350 {
32351 PyThreadState* __tstate = wxPyBeginAllowThreads();
32352 result = (wxValidator *)new wxValidator();
32353
32354 wxPyEndAllowThreads(__tstate);
32355 if (PyErr_Occurred()) SWIG_fail;
32356 }
32357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32358 return resultobj;
32359 fail:
32360 return NULL;
32361 }
32362
32363
32364 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32365 PyObject *resultobj;
32366 wxValidator *arg1 = (wxValidator *) 0 ;
32367 wxValidator *result;
32368 PyObject * obj0 = 0 ;
32369 char *kwnames[] = {
32370 (char *) "self", NULL
32371 };
32372
32373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32375 if (SWIG_arg_fail(1)) SWIG_fail;
32376 {
32377 PyThreadState* __tstate = wxPyBeginAllowThreads();
32378 result = (wxValidator *)(arg1)->Clone();
32379
32380 wxPyEndAllowThreads(__tstate);
32381 if (PyErr_Occurred()) SWIG_fail;
32382 }
32383 {
32384 resultobj = wxPyMake_wxObject(result, 0);
32385 }
32386 return resultobj;
32387 fail:
32388 return NULL;
32389 }
32390
32391
32392 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32393 PyObject *resultobj;
32394 wxValidator *arg1 = (wxValidator *) 0 ;
32395 wxWindow *arg2 = (wxWindow *) 0 ;
32396 bool result;
32397 PyObject * obj0 = 0 ;
32398 PyObject * obj1 = 0 ;
32399 char *kwnames[] = {
32400 (char *) "self",(char *) "parent", NULL
32401 };
32402
32403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32405 if (SWIG_arg_fail(1)) SWIG_fail;
32406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32407 if (SWIG_arg_fail(2)) SWIG_fail;
32408 {
32409 PyThreadState* __tstate = wxPyBeginAllowThreads();
32410 result = (bool)(arg1)->Validate(arg2);
32411
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32425 PyObject *resultobj;
32426 wxValidator *arg1 = (wxValidator *) 0 ;
32427 bool result;
32428 PyObject * obj0 = 0 ;
32429 char *kwnames[] = {
32430 (char *) "self", NULL
32431 };
32432
32433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32435 if (SWIG_arg_fail(1)) SWIG_fail;
32436 {
32437 PyThreadState* __tstate = wxPyBeginAllowThreads();
32438 result = (bool)(arg1)->TransferToWindow();
32439
32440 wxPyEndAllowThreads(__tstate);
32441 if (PyErr_Occurred()) SWIG_fail;
32442 }
32443 {
32444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32445 }
32446 return resultobj;
32447 fail:
32448 return NULL;
32449 }
32450
32451
32452 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32453 PyObject *resultobj;
32454 wxValidator *arg1 = (wxValidator *) 0 ;
32455 bool result;
32456 PyObject * obj0 = 0 ;
32457 char *kwnames[] = {
32458 (char *) "self", NULL
32459 };
32460
32461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32463 if (SWIG_arg_fail(1)) SWIG_fail;
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 result = (bool)(arg1)->TransferFromWindow();
32467
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 {
32472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32473 }
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32481 PyObject *resultobj;
32482 wxValidator *arg1 = (wxValidator *) 0 ;
32483 wxWindow *result;
32484 PyObject * obj0 = 0 ;
32485 char *kwnames[] = {
32486 (char *) "self", NULL
32487 };
32488
32489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32491 if (SWIG_arg_fail(1)) SWIG_fail;
32492 {
32493 PyThreadState* __tstate = wxPyBeginAllowThreads();
32494 result = (wxWindow *)(arg1)->GetWindow();
32495
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 {
32500 resultobj = wxPyMake_wxObject(result, 0);
32501 }
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32509 PyObject *resultobj;
32510 wxValidator *arg1 = (wxValidator *) 0 ;
32511 wxWindow *arg2 = (wxWindow *) 0 ;
32512 PyObject * obj0 = 0 ;
32513 PyObject * obj1 = 0 ;
32514 char *kwnames[] = {
32515 (char *) "self",(char *) "window", NULL
32516 };
32517
32518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32520 if (SWIG_arg_fail(1)) SWIG_fail;
32521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32522 if (SWIG_arg_fail(2)) SWIG_fail;
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 (arg1)->SetWindow(arg2);
32526
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 Py_INCREF(Py_None); resultobj = Py_None;
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32538 PyObject *resultobj;
32539 bool result;
32540 char *kwnames[] = {
32541 NULL
32542 };
32543
32544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = (bool)wxValidator::IsSilent();
32548
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 {
32553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32554 }
32555 return resultobj;
32556 fail:
32557 return NULL;
32558 }
32559
32560
32561 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32562 PyObject *resultobj;
32563 int arg1 = (int) true ;
32564 PyObject * obj0 = 0 ;
32565 char *kwnames[] = {
32566 (char *) "doIt", NULL
32567 };
32568
32569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32570 if (obj0) {
32571 {
32572 arg1 = (int)(SWIG_As_int(obj0));
32573 if (SWIG_arg_fail(1)) SWIG_fail;
32574 }
32575 }
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 wxValidator::SetBellOnError(arg1);
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 * Validator_swigregister(PyObject *, PyObject *args) {
32591 PyObject *obj;
32592 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32593 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32594 Py_INCREF(obj);
32595 return Py_BuildValue((char *)"");
32596 }
32597 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32598 PyObject *resultobj;
32599 wxPyValidator *result;
32600 char *kwnames[] = {
32601 NULL
32602 };
32603
32604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxPyValidator *)new wxPyValidator();
32608
32609 wxPyEndAllowThreads(__tstate);
32610 if (PyErr_Occurred()) SWIG_fail;
32611 }
32612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32613 return resultobj;
32614 fail:
32615 return NULL;
32616 }
32617
32618
32619 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32620 PyObject *resultobj;
32621 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32622 PyObject *arg2 = (PyObject *) 0 ;
32623 PyObject *arg3 = (PyObject *) 0 ;
32624 int arg4 = (int) true ;
32625 PyObject * obj0 = 0 ;
32626 PyObject * obj1 = 0 ;
32627 PyObject * obj2 = 0 ;
32628 PyObject * obj3 = 0 ;
32629 char *kwnames[] = {
32630 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32631 };
32632
32633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32635 if (SWIG_arg_fail(1)) SWIG_fail;
32636 arg2 = obj1;
32637 arg3 = obj2;
32638 if (obj3) {
32639 {
32640 arg4 = (int)(SWIG_As_int(obj3));
32641 if (SWIG_arg_fail(4)) SWIG_fail;
32642 }
32643 }
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32647
32648 wxPyEndAllowThreads(__tstate);
32649 if (PyErr_Occurred()) SWIG_fail;
32650 }
32651 Py_INCREF(Py_None); resultobj = Py_None;
32652 return resultobj;
32653 fail:
32654 return NULL;
32655 }
32656
32657
32658 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32659 PyObject *obj;
32660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32661 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32662 Py_INCREF(obj);
32663 return Py_BuildValue((char *)"");
32664 }
32665 static int _wrap_DefaultValidator_set(PyObject *) {
32666 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32667 return 1;
32668 }
32669
32670
32671 static PyObject *_wrap_DefaultValidator_get(void) {
32672 PyObject *pyobj;
32673
32674 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32675 return pyobj;
32676 }
32677
32678
32679 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32680 PyObject *resultobj;
32681 wxString const &arg1_defvalue = wxPyEmptyString ;
32682 wxString *arg1 = (wxString *) &arg1_defvalue ;
32683 long arg2 = (long) 0 ;
32684 wxMenu *result;
32685 bool temp1 = false ;
32686 PyObject * obj0 = 0 ;
32687 PyObject * obj1 = 0 ;
32688 char *kwnames[] = {
32689 (char *) "title",(char *) "style", NULL
32690 };
32691
32692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32693 if (obj0) {
32694 {
32695 arg1 = wxString_in_helper(obj0);
32696 if (arg1 == NULL) SWIG_fail;
32697 temp1 = true;
32698 }
32699 }
32700 if (obj1) {
32701 {
32702 arg2 = (long)(SWIG_As_long(obj1));
32703 if (SWIG_arg_fail(2)) SWIG_fail;
32704 }
32705 }
32706 {
32707 if (!wxPyCheckForApp()) SWIG_fail;
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32710
32711 wxPyEndAllowThreads(__tstate);
32712 if (PyErr_Occurred()) SWIG_fail;
32713 }
32714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32715 {
32716 if (temp1)
32717 delete arg1;
32718 }
32719 return resultobj;
32720 fail:
32721 {
32722 if (temp1)
32723 delete arg1;
32724 }
32725 return NULL;
32726 }
32727
32728
32729 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32730 PyObject *resultobj;
32731 wxMenu *arg1 = (wxMenu *) 0 ;
32732 int arg2 ;
32733 wxString *arg3 = 0 ;
32734 wxString const &arg4_defvalue = wxPyEmptyString ;
32735 wxString *arg4 = (wxString *) &arg4_defvalue ;
32736 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32737 wxMenuItem *result;
32738 bool temp3 = false ;
32739 bool temp4 = false ;
32740 PyObject * obj0 = 0 ;
32741 PyObject * obj1 = 0 ;
32742 PyObject * obj2 = 0 ;
32743 PyObject * obj3 = 0 ;
32744 PyObject * obj4 = 0 ;
32745 char *kwnames[] = {
32746 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32747 };
32748
32749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32751 if (SWIG_arg_fail(1)) SWIG_fail;
32752 {
32753 arg2 = (int)(SWIG_As_int(obj1));
32754 if (SWIG_arg_fail(2)) SWIG_fail;
32755 }
32756 {
32757 arg3 = wxString_in_helper(obj2);
32758 if (arg3 == NULL) SWIG_fail;
32759 temp3 = true;
32760 }
32761 if (obj3) {
32762 {
32763 arg4 = wxString_in_helper(obj3);
32764 if (arg4 == NULL) SWIG_fail;
32765 temp4 = true;
32766 }
32767 }
32768 if (obj4) {
32769 {
32770 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32771 if (SWIG_arg_fail(5)) SWIG_fail;
32772 }
32773 }
32774 {
32775 PyThreadState* __tstate = wxPyBeginAllowThreads();
32776 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32777
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 {
32782 resultobj = wxPyMake_wxObject(result, 0);
32783 }
32784 {
32785 if (temp3)
32786 delete arg3;
32787 }
32788 {
32789 if (temp4)
32790 delete arg4;
32791 }
32792 return resultobj;
32793 fail:
32794 {
32795 if (temp3)
32796 delete arg3;
32797 }
32798 {
32799 if (temp4)
32800 delete arg4;
32801 }
32802 return NULL;
32803 }
32804
32805
32806 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32807 PyObject *resultobj;
32808 wxMenu *arg1 = (wxMenu *) 0 ;
32809 wxMenuItem *result;
32810 PyObject * obj0 = 0 ;
32811 char *kwnames[] = {
32812 (char *) "self", NULL
32813 };
32814
32815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32817 if (SWIG_arg_fail(1)) SWIG_fail;
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (wxMenuItem *)(arg1)->AppendSeparator();
32821
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = wxPyMake_wxObject(result, 0);
32827 }
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32835 PyObject *resultobj;
32836 wxMenu *arg1 = (wxMenu *) 0 ;
32837 int arg2 ;
32838 wxString *arg3 = 0 ;
32839 wxString const &arg4_defvalue = wxPyEmptyString ;
32840 wxString *arg4 = (wxString *) &arg4_defvalue ;
32841 wxMenuItem *result;
32842 bool temp3 = false ;
32843 bool temp4 = false ;
32844 PyObject * obj0 = 0 ;
32845 PyObject * obj1 = 0 ;
32846 PyObject * obj2 = 0 ;
32847 PyObject * obj3 = 0 ;
32848 char *kwnames[] = {
32849 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32850 };
32851
32852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32854 if (SWIG_arg_fail(1)) SWIG_fail;
32855 {
32856 arg2 = (int)(SWIG_As_int(obj1));
32857 if (SWIG_arg_fail(2)) SWIG_fail;
32858 }
32859 {
32860 arg3 = wxString_in_helper(obj2);
32861 if (arg3 == NULL) SWIG_fail;
32862 temp3 = true;
32863 }
32864 if (obj3) {
32865 {
32866 arg4 = wxString_in_helper(obj3);
32867 if (arg4 == NULL) SWIG_fail;
32868 temp4 = true;
32869 }
32870 }
32871 {
32872 PyThreadState* __tstate = wxPyBeginAllowThreads();
32873 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32874
32875 wxPyEndAllowThreads(__tstate);
32876 if (PyErr_Occurred()) SWIG_fail;
32877 }
32878 {
32879 resultobj = wxPyMake_wxObject(result, 0);
32880 }
32881 {
32882 if (temp3)
32883 delete arg3;
32884 }
32885 {
32886 if (temp4)
32887 delete arg4;
32888 }
32889 return resultobj;
32890 fail:
32891 {
32892 if (temp3)
32893 delete arg3;
32894 }
32895 {
32896 if (temp4)
32897 delete arg4;
32898 }
32899 return NULL;
32900 }
32901
32902
32903 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32904 PyObject *resultobj;
32905 wxMenu *arg1 = (wxMenu *) 0 ;
32906 int arg2 ;
32907 wxString *arg3 = 0 ;
32908 wxString const &arg4_defvalue = wxPyEmptyString ;
32909 wxString *arg4 = (wxString *) &arg4_defvalue ;
32910 wxMenuItem *result;
32911 bool temp3 = false ;
32912 bool temp4 = false ;
32913 PyObject * obj0 = 0 ;
32914 PyObject * obj1 = 0 ;
32915 PyObject * obj2 = 0 ;
32916 PyObject * obj3 = 0 ;
32917 char *kwnames[] = {
32918 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32919 };
32920
32921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32923 if (SWIG_arg_fail(1)) SWIG_fail;
32924 {
32925 arg2 = (int)(SWIG_As_int(obj1));
32926 if (SWIG_arg_fail(2)) SWIG_fail;
32927 }
32928 {
32929 arg3 = wxString_in_helper(obj2);
32930 if (arg3 == NULL) SWIG_fail;
32931 temp3 = true;
32932 }
32933 if (obj3) {
32934 {
32935 arg4 = wxString_in_helper(obj3);
32936 if (arg4 == NULL) SWIG_fail;
32937 temp4 = true;
32938 }
32939 }
32940 {
32941 PyThreadState* __tstate = wxPyBeginAllowThreads();
32942 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32943
32944 wxPyEndAllowThreads(__tstate);
32945 if (PyErr_Occurred()) SWIG_fail;
32946 }
32947 {
32948 resultobj = wxPyMake_wxObject(result, 0);
32949 }
32950 {
32951 if (temp3)
32952 delete arg3;
32953 }
32954 {
32955 if (temp4)
32956 delete arg4;
32957 }
32958 return resultobj;
32959 fail:
32960 {
32961 if (temp3)
32962 delete arg3;
32963 }
32964 {
32965 if (temp4)
32966 delete arg4;
32967 }
32968 return NULL;
32969 }
32970
32971
32972 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32973 PyObject *resultobj;
32974 wxMenu *arg1 = (wxMenu *) 0 ;
32975 int arg2 ;
32976 wxString *arg3 = 0 ;
32977 wxMenu *arg4 = (wxMenu *) 0 ;
32978 wxString const &arg5_defvalue = wxPyEmptyString ;
32979 wxString *arg5 = (wxString *) &arg5_defvalue ;
32980 wxMenuItem *result;
32981 bool temp3 = false ;
32982 bool temp5 = false ;
32983 PyObject * obj0 = 0 ;
32984 PyObject * obj1 = 0 ;
32985 PyObject * obj2 = 0 ;
32986 PyObject * obj3 = 0 ;
32987 PyObject * obj4 = 0 ;
32988 char *kwnames[] = {
32989 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32990 };
32991
32992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32994 if (SWIG_arg_fail(1)) SWIG_fail;
32995 {
32996 arg2 = (int)(SWIG_As_int(obj1));
32997 if (SWIG_arg_fail(2)) SWIG_fail;
32998 }
32999 {
33000 arg3 = wxString_in_helper(obj2);
33001 if (arg3 == NULL) SWIG_fail;
33002 temp3 = true;
33003 }
33004 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33005 if (SWIG_arg_fail(4)) SWIG_fail;
33006 if (obj4) {
33007 {
33008 arg5 = wxString_in_helper(obj4);
33009 if (arg5 == NULL) SWIG_fail;
33010 temp5 = true;
33011 }
33012 }
33013 {
33014 PyThreadState* __tstate = wxPyBeginAllowThreads();
33015 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33016
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = wxPyMake_wxObject(result, 0);
33022 }
33023 {
33024 if (temp3)
33025 delete arg3;
33026 }
33027 {
33028 if (temp5)
33029 delete arg5;
33030 }
33031 return resultobj;
33032 fail:
33033 {
33034 if (temp3)
33035 delete arg3;
33036 }
33037 {
33038 if (temp5)
33039 delete arg5;
33040 }
33041 return NULL;
33042 }
33043
33044
33045 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33046 PyObject *resultobj;
33047 wxMenu *arg1 = (wxMenu *) 0 ;
33048 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33049 wxMenuItem *result;
33050 PyObject * obj0 = 0 ;
33051 PyObject * obj1 = 0 ;
33052 char *kwnames[] = {
33053 (char *) "self",(char *) "item", NULL
33054 };
33055
33056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33058 if (SWIG_arg_fail(1)) SWIG_fail;
33059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33060 if (SWIG_arg_fail(2)) SWIG_fail;
33061 {
33062 PyThreadState* __tstate = wxPyBeginAllowThreads();
33063 result = (wxMenuItem *)(arg1)->Append(arg2);
33064
33065 wxPyEndAllowThreads(__tstate);
33066 if (PyErr_Occurred()) SWIG_fail;
33067 }
33068 {
33069 resultobj = wxPyMake_wxObject(result, 0);
33070 }
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33078 PyObject *resultobj;
33079 wxMenu *arg1 = (wxMenu *) 0 ;
33080 PyObject * obj0 = 0 ;
33081 char *kwnames[] = {
33082 (char *) "self", NULL
33083 };
33084
33085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33087 if (SWIG_arg_fail(1)) SWIG_fail;
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 (arg1)->Break();
33091
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 Py_INCREF(Py_None); resultobj = Py_None;
33096 return resultobj;
33097 fail:
33098 return NULL;
33099 }
33100
33101
33102 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33103 PyObject *resultobj;
33104 wxMenu *arg1 = (wxMenu *) 0 ;
33105 size_t arg2 ;
33106 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33107 wxMenuItem *result;
33108 PyObject * obj0 = 0 ;
33109 PyObject * obj1 = 0 ;
33110 PyObject * obj2 = 0 ;
33111 char *kwnames[] = {
33112 (char *) "self",(char *) "pos",(char *) "item", NULL
33113 };
33114
33115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33117 if (SWIG_arg_fail(1)) SWIG_fail;
33118 {
33119 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33120 if (SWIG_arg_fail(2)) SWIG_fail;
33121 }
33122 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33123 if (SWIG_arg_fail(3)) SWIG_fail;
33124 {
33125 PyThreadState* __tstate = wxPyBeginAllowThreads();
33126 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33127
33128 wxPyEndAllowThreads(__tstate);
33129 if (PyErr_Occurred()) SWIG_fail;
33130 }
33131 {
33132 resultobj = wxPyMake_wxObject(result, 0);
33133 }
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33141 PyObject *resultobj;
33142 wxMenu *arg1 = (wxMenu *) 0 ;
33143 size_t arg2 ;
33144 int arg3 ;
33145 wxString *arg4 = 0 ;
33146 wxString const &arg5_defvalue = wxPyEmptyString ;
33147 wxString *arg5 = (wxString *) &arg5_defvalue ;
33148 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33149 wxMenuItem *result;
33150 bool temp4 = false ;
33151 bool temp5 = false ;
33152 PyObject * obj0 = 0 ;
33153 PyObject * obj1 = 0 ;
33154 PyObject * obj2 = 0 ;
33155 PyObject * obj3 = 0 ;
33156 PyObject * obj4 = 0 ;
33157 PyObject * obj5 = 0 ;
33158 char *kwnames[] = {
33159 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33160 };
33161
33162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33164 if (SWIG_arg_fail(1)) SWIG_fail;
33165 {
33166 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33167 if (SWIG_arg_fail(2)) SWIG_fail;
33168 }
33169 {
33170 arg3 = (int)(SWIG_As_int(obj2));
33171 if (SWIG_arg_fail(3)) SWIG_fail;
33172 }
33173 {
33174 arg4 = wxString_in_helper(obj3);
33175 if (arg4 == NULL) SWIG_fail;
33176 temp4 = true;
33177 }
33178 if (obj4) {
33179 {
33180 arg5 = wxString_in_helper(obj4);
33181 if (arg5 == NULL) SWIG_fail;
33182 temp5 = true;
33183 }
33184 }
33185 if (obj5) {
33186 {
33187 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33188 if (SWIG_arg_fail(6)) SWIG_fail;
33189 }
33190 }
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33194
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 {
33199 resultobj = wxPyMake_wxObject(result, 0);
33200 }
33201 {
33202 if (temp4)
33203 delete arg4;
33204 }
33205 {
33206 if (temp5)
33207 delete arg5;
33208 }
33209 return resultobj;
33210 fail:
33211 {
33212 if (temp4)
33213 delete arg4;
33214 }
33215 {
33216 if (temp5)
33217 delete arg5;
33218 }
33219 return NULL;
33220 }
33221
33222
33223 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33224 PyObject *resultobj;
33225 wxMenu *arg1 = (wxMenu *) 0 ;
33226 size_t arg2 ;
33227 wxMenuItem *result;
33228 PyObject * obj0 = 0 ;
33229 PyObject * obj1 = 0 ;
33230 char *kwnames[] = {
33231 (char *) "self",(char *) "pos", NULL
33232 };
33233
33234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33236 if (SWIG_arg_fail(1)) SWIG_fail;
33237 {
33238 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33239 if (SWIG_arg_fail(2)) SWIG_fail;
33240 }
33241 {
33242 PyThreadState* __tstate = wxPyBeginAllowThreads();
33243 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33244
33245 wxPyEndAllowThreads(__tstate);
33246 if (PyErr_Occurred()) SWIG_fail;
33247 }
33248 {
33249 resultobj = wxPyMake_wxObject(result, 0);
33250 }
33251 return resultobj;
33252 fail:
33253 return NULL;
33254 }
33255
33256
33257 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33258 PyObject *resultobj;
33259 wxMenu *arg1 = (wxMenu *) 0 ;
33260 size_t arg2 ;
33261 int arg3 ;
33262 wxString *arg4 = 0 ;
33263 wxString const &arg5_defvalue = wxPyEmptyString ;
33264 wxString *arg5 = (wxString *) &arg5_defvalue ;
33265 wxMenuItem *result;
33266 bool temp4 = false ;
33267 bool temp5 = false ;
33268 PyObject * obj0 = 0 ;
33269 PyObject * obj1 = 0 ;
33270 PyObject * obj2 = 0 ;
33271 PyObject * obj3 = 0 ;
33272 PyObject * obj4 = 0 ;
33273 char *kwnames[] = {
33274 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33275 };
33276
33277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33279 if (SWIG_arg_fail(1)) SWIG_fail;
33280 {
33281 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33282 if (SWIG_arg_fail(2)) SWIG_fail;
33283 }
33284 {
33285 arg3 = (int)(SWIG_As_int(obj2));
33286 if (SWIG_arg_fail(3)) SWIG_fail;
33287 }
33288 {
33289 arg4 = wxString_in_helper(obj3);
33290 if (arg4 == NULL) SWIG_fail;
33291 temp4 = true;
33292 }
33293 if (obj4) {
33294 {
33295 arg5 = wxString_in_helper(obj4);
33296 if (arg5 == NULL) SWIG_fail;
33297 temp5 = true;
33298 }
33299 }
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33303
33304 wxPyEndAllowThreads(__tstate);
33305 if (PyErr_Occurred()) SWIG_fail;
33306 }
33307 {
33308 resultobj = wxPyMake_wxObject(result, 0);
33309 }
33310 {
33311 if (temp4)
33312 delete arg4;
33313 }
33314 {
33315 if (temp5)
33316 delete arg5;
33317 }
33318 return resultobj;
33319 fail:
33320 {
33321 if (temp4)
33322 delete arg4;
33323 }
33324 {
33325 if (temp5)
33326 delete arg5;
33327 }
33328 return NULL;
33329 }
33330
33331
33332 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33333 PyObject *resultobj;
33334 wxMenu *arg1 = (wxMenu *) 0 ;
33335 size_t arg2 ;
33336 int arg3 ;
33337 wxString *arg4 = 0 ;
33338 wxString const &arg5_defvalue = wxPyEmptyString ;
33339 wxString *arg5 = (wxString *) &arg5_defvalue ;
33340 wxMenuItem *result;
33341 bool temp4 = false ;
33342 bool temp5 = false ;
33343 PyObject * obj0 = 0 ;
33344 PyObject * obj1 = 0 ;
33345 PyObject * obj2 = 0 ;
33346 PyObject * obj3 = 0 ;
33347 PyObject * obj4 = 0 ;
33348 char *kwnames[] = {
33349 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33350 };
33351
33352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33354 if (SWIG_arg_fail(1)) SWIG_fail;
33355 {
33356 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33357 if (SWIG_arg_fail(2)) SWIG_fail;
33358 }
33359 {
33360 arg3 = (int)(SWIG_As_int(obj2));
33361 if (SWIG_arg_fail(3)) SWIG_fail;
33362 }
33363 {
33364 arg4 = wxString_in_helper(obj3);
33365 if (arg4 == NULL) SWIG_fail;
33366 temp4 = true;
33367 }
33368 if (obj4) {
33369 {
33370 arg5 = wxString_in_helper(obj4);
33371 if (arg5 == NULL) SWIG_fail;
33372 temp5 = true;
33373 }
33374 }
33375 {
33376 PyThreadState* __tstate = wxPyBeginAllowThreads();
33377 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33378
33379 wxPyEndAllowThreads(__tstate);
33380 if (PyErr_Occurred()) SWIG_fail;
33381 }
33382 {
33383 resultobj = wxPyMake_wxObject(result, 0);
33384 }
33385 {
33386 if (temp4)
33387 delete arg4;
33388 }
33389 {
33390 if (temp5)
33391 delete arg5;
33392 }
33393 return resultobj;
33394 fail:
33395 {
33396 if (temp4)
33397 delete arg4;
33398 }
33399 {
33400 if (temp5)
33401 delete arg5;
33402 }
33403 return NULL;
33404 }
33405
33406
33407 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33408 PyObject *resultobj;
33409 wxMenu *arg1 = (wxMenu *) 0 ;
33410 size_t arg2 ;
33411 int arg3 ;
33412 wxString *arg4 = 0 ;
33413 wxMenu *arg5 = (wxMenu *) 0 ;
33414 wxString const &arg6_defvalue = wxPyEmptyString ;
33415 wxString *arg6 = (wxString *) &arg6_defvalue ;
33416 wxMenuItem *result;
33417 bool temp4 = false ;
33418 bool temp6 = false ;
33419 PyObject * obj0 = 0 ;
33420 PyObject * obj1 = 0 ;
33421 PyObject * obj2 = 0 ;
33422 PyObject * obj3 = 0 ;
33423 PyObject * obj4 = 0 ;
33424 PyObject * obj5 = 0 ;
33425 char *kwnames[] = {
33426 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33427 };
33428
33429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 {
33433 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33434 if (SWIG_arg_fail(2)) SWIG_fail;
33435 }
33436 {
33437 arg3 = (int)(SWIG_As_int(obj2));
33438 if (SWIG_arg_fail(3)) SWIG_fail;
33439 }
33440 {
33441 arg4 = wxString_in_helper(obj3);
33442 if (arg4 == NULL) SWIG_fail;
33443 temp4 = true;
33444 }
33445 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33446 if (SWIG_arg_fail(5)) SWIG_fail;
33447 if (obj5) {
33448 {
33449 arg6 = wxString_in_helper(obj5);
33450 if (arg6 == NULL) SWIG_fail;
33451 temp6 = true;
33452 }
33453 }
33454 {
33455 PyThreadState* __tstate = wxPyBeginAllowThreads();
33456 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33457
33458 wxPyEndAllowThreads(__tstate);
33459 if (PyErr_Occurred()) SWIG_fail;
33460 }
33461 {
33462 resultobj = wxPyMake_wxObject(result, 0);
33463 }
33464 {
33465 if (temp4)
33466 delete arg4;
33467 }
33468 {
33469 if (temp6)
33470 delete arg6;
33471 }
33472 return resultobj;
33473 fail:
33474 {
33475 if (temp4)
33476 delete arg4;
33477 }
33478 {
33479 if (temp6)
33480 delete arg6;
33481 }
33482 return NULL;
33483 }
33484
33485
33486 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33487 PyObject *resultobj;
33488 wxMenu *arg1 = (wxMenu *) 0 ;
33489 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33490 wxMenuItem *result;
33491 PyObject * obj0 = 0 ;
33492 PyObject * obj1 = 0 ;
33493 char *kwnames[] = {
33494 (char *) "self",(char *) "item", NULL
33495 };
33496
33497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33499 if (SWIG_arg_fail(1)) SWIG_fail;
33500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33501 if (SWIG_arg_fail(2)) SWIG_fail;
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33505
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 {
33510 resultobj = wxPyMake_wxObject(result, 0);
33511 }
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj;
33520 wxMenu *arg1 = (wxMenu *) 0 ;
33521 int arg2 ;
33522 wxString *arg3 = 0 ;
33523 wxString const &arg4_defvalue = wxPyEmptyString ;
33524 wxString *arg4 = (wxString *) &arg4_defvalue ;
33525 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33526 wxMenuItem *result;
33527 bool temp3 = false ;
33528 bool temp4 = false ;
33529 PyObject * obj0 = 0 ;
33530 PyObject * obj1 = 0 ;
33531 PyObject * obj2 = 0 ;
33532 PyObject * obj3 = 0 ;
33533 PyObject * obj4 = 0 ;
33534 char *kwnames[] = {
33535 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33536 };
33537
33538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33540 if (SWIG_arg_fail(1)) SWIG_fail;
33541 {
33542 arg2 = (int)(SWIG_As_int(obj1));
33543 if (SWIG_arg_fail(2)) SWIG_fail;
33544 }
33545 {
33546 arg3 = wxString_in_helper(obj2);
33547 if (arg3 == NULL) SWIG_fail;
33548 temp3 = true;
33549 }
33550 if (obj3) {
33551 {
33552 arg4 = wxString_in_helper(obj3);
33553 if (arg4 == NULL) SWIG_fail;
33554 temp4 = true;
33555 }
33556 }
33557 if (obj4) {
33558 {
33559 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33560 if (SWIG_arg_fail(5)) SWIG_fail;
33561 }
33562 }
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33566
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 {
33571 resultobj = wxPyMake_wxObject(result, 0);
33572 }
33573 {
33574 if (temp3)
33575 delete arg3;
33576 }
33577 {
33578 if (temp4)
33579 delete arg4;
33580 }
33581 return resultobj;
33582 fail:
33583 {
33584 if (temp3)
33585 delete arg3;
33586 }
33587 {
33588 if (temp4)
33589 delete arg4;
33590 }
33591 return NULL;
33592 }
33593
33594
33595 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33596 PyObject *resultobj;
33597 wxMenu *arg1 = (wxMenu *) 0 ;
33598 wxMenuItem *result;
33599 PyObject * obj0 = 0 ;
33600 char *kwnames[] = {
33601 (char *) "self", NULL
33602 };
33603
33604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33606 if (SWIG_arg_fail(1)) SWIG_fail;
33607 {
33608 PyThreadState* __tstate = wxPyBeginAllowThreads();
33609 result = (wxMenuItem *)(arg1)->PrependSeparator();
33610
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 {
33615 resultobj = wxPyMake_wxObject(result, 0);
33616 }
33617 return resultobj;
33618 fail:
33619 return NULL;
33620 }
33621
33622
33623 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33624 PyObject *resultobj;
33625 wxMenu *arg1 = (wxMenu *) 0 ;
33626 int arg2 ;
33627 wxString *arg3 = 0 ;
33628 wxString const &arg4_defvalue = wxPyEmptyString ;
33629 wxString *arg4 = (wxString *) &arg4_defvalue ;
33630 wxMenuItem *result;
33631 bool temp3 = false ;
33632 bool temp4 = false ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 PyObject * obj2 = 0 ;
33636 PyObject * obj3 = 0 ;
33637 char *kwnames[] = {
33638 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33639 };
33640
33641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33643 if (SWIG_arg_fail(1)) SWIG_fail;
33644 {
33645 arg2 = (int)(SWIG_As_int(obj1));
33646 if (SWIG_arg_fail(2)) SWIG_fail;
33647 }
33648 {
33649 arg3 = wxString_in_helper(obj2);
33650 if (arg3 == NULL) SWIG_fail;
33651 temp3 = true;
33652 }
33653 if (obj3) {
33654 {
33655 arg4 = wxString_in_helper(obj3);
33656 if (arg4 == NULL) SWIG_fail;
33657 temp4 = true;
33658 }
33659 }
33660 {
33661 PyThreadState* __tstate = wxPyBeginAllowThreads();
33662 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33663
33664 wxPyEndAllowThreads(__tstate);
33665 if (PyErr_Occurred()) SWIG_fail;
33666 }
33667 {
33668 resultobj = wxPyMake_wxObject(result, 0);
33669 }
33670 {
33671 if (temp3)
33672 delete arg3;
33673 }
33674 {
33675 if (temp4)
33676 delete arg4;
33677 }
33678 return resultobj;
33679 fail:
33680 {
33681 if (temp3)
33682 delete arg3;
33683 }
33684 {
33685 if (temp4)
33686 delete arg4;
33687 }
33688 return NULL;
33689 }
33690
33691
33692 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33693 PyObject *resultobj;
33694 wxMenu *arg1 = (wxMenu *) 0 ;
33695 int arg2 ;
33696 wxString *arg3 = 0 ;
33697 wxString const &arg4_defvalue = wxPyEmptyString ;
33698 wxString *arg4 = (wxString *) &arg4_defvalue ;
33699 wxMenuItem *result;
33700 bool temp3 = false ;
33701 bool temp4 = false ;
33702 PyObject * obj0 = 0 ;
33703 PyObject * obj1 = 0 ;
33704 PyObject * obj2 = 0 ;
33705 PyObject * obj3 = 0 ;
33706 char *kwnames[] = {
33707 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33708 };
33709
33710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33712 if (SWIG_arg_fail(1)) SWIG_fail;
33713 {
33714 arg2 = (int)(SWIG_As_int(obj1));
33715 if (SWIG_arg_fail(2)) SWIG_fail;
33716 }
33717 {
33718 arg3 = wxString_in_helper(obj2);
33719 if (arg3 == NULL) SWIG_fail;
33720 temp3 = true;
33721 }
33722 if (obj3) {
33723 {
33724 arg4 = wxString_in_helper(obj3);
33725 if (arg4 == NULL) SWIG_fail;
33726 temp4 = true;
33727 }
33728 }
33729 {
33730 PyThreadState* __tstate = wxPyBeginAllowThreads();
33731 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33732
33733 wxPyEndAllowThreads(__tstate);
33734 if (PyErr_Occurred()) SWIG_fail;
33735 }
33736 {
33737 resultobj = wxPyMake_wxObject(result, 0);
33738 }
33739 {
33740 if (temp3)
33741 delete arg3;
33742 }
33743 {
33744 if (temp4)
33745 delete arg4;
33746 }
33747 return resultobj;
33748 fail:
33749 {
33750 if (temp3)
33751 delete arg3;
33752 }
33753 {
33754 if (temp4)
33755 delete arg4;
33756 }
33757 return NULL;
33758 }
33759
33760
33761 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33762 PyObject *resultobj;
33763 wxMenu *arg1 = (wxMenu *) 0 ;
33764 int arg2 ;
33765 wxString *arg3 = 0 ;
33766 wxMenu *arg4 = (wxMenu *) 0 ;
33767 wxString const &arg5_defvalue = wxPyEmptyString ;
33768 wxString *arg5 = (wxString *) &arg5_defvalue ;
33769 wxMenuItem *result;
33770 bool temp3 = false ;
33771 bool temp5 = false ;
33772 PyObject * obj0 = 0 ;
33773 PyObject * obj1 = 0 ;
33774 PyObject * obj2 = 0 ;
33775 PyObject * obj3 = 0 ;
33776 PyObject * obj4 = 0 ;
33777 char *kwnames[] = {
33778 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33779 };
33780
33781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33783 if (SWIG_arg_fail(1)) SWIG_fail;
33784 {
33785 arg2 = (int)(SWIG_As_int(obj1));
33786 if (SWIG_arg_fail(2)) SWIG_fail;
33787 }
33788 {
33789 arg3 = wxString_in_helper(obj2);
33790 if (arg3 == NULL) SWIG_fail;
33791 temp3 = true;
33792 }
33793 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33794 if (SWIG_arg_fail(4)) SWIG_fail;
33795 if (obj4) {
33796 {
33797 arg5 = wxString_in_helper(obj4);
33798 if (arg5 == NULL) SWIG_fail;
33799 temp5 = true;
33800 }
33801 }
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33805
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 {
33810 resultobj = wxPyMake_wxObject(result, 0);
33811 }
33812 {
33813 if (temp3)
33814 delete arg3;
33815 }
33816 {
33817 if (temp5)
33818 delete arg5;
33819 }
33820 return resultobj;
33821 fail:
33822 {
33823 if (temp3)
33824 delete arg3;
33825 }
33826 {
33827 if (temp5)
33828 delete arg5;
33829 }
33830 return NULL;
33831 }
33832
33833
33834 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33835 PyObject *resultobj;
33836 wxMenu *arg1 = (wxMenu *) 0 ;
33837 int arg2 ;
33838 wxMenuItem *result;
33839 PyObject * obj0 = 0 ;
33840 PyObject * obj1 = 0 ;
33841 char *kwnames[] = {
33842 (char *) "self",(char *) "id", NULL
33843 };
33844
33845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33847 if (SWIG_arg_fail(1)) SWIG_fail;
33848 {
33849 arg2 = (int)(SWIG_As_int(obj1));
33850 if (SWIG_arg_fail(2)) SWIG_fail;
33851 }
33852 {
33853 PyThreadState* __tstate = wxPyBeginAllowThreads();
33854 result = (wxMenuItem *)(arg1)->Remove(arg2);
33855
33856 wxPyEndAllowThreads(__tstate);
33857 if (PyErr_Occurred()) SWIG_fail;
33858 }
33859 {
33860 resultobj = wxPyMake_wxObject(result, 0);
33861 }
33862 return resultobj;
33863 fail:
33864 return NULL;
33865 }
33866
33867
33868 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj;
33870 wxMenu *arg1 = (wxMenu *) 0 ;
33871 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33872 wxMenuItem *result;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 char *kwnames[] = {
33876 (char *) "self",(char *) "item", NULL
33877 };
33878
33879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(1)) SWIG_fail;
33882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33883 if (SWIG_arg_fail(2)) SWIG_fail;
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (wxMenuItem *)(arg1)->Remove(arg2);
33887
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 {
33892 resultobj = wxPyMake_wxObject(result, 0);
33893 }
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj;
33902 wxMenu *arg1 = (wxMenu *) 0 ;
33903 int arg2 ;
33904 bool result;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 char *kwnames[] = {
33908 (char *) "self",(char *) "id", NULL
33909 };
33910
33911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33913 if (SWIG_arg_fail(1)) SWIG_fail;
33914 {
33915 arg2 = (int)(SWIG_As_int(obj1));
33916 if (SWIG_arg_fail(2)) SWIG_fail;
33917 }
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 result = (bool)(arg1)->Delete(arg2);
33921
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 {
33926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33927 }
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33935 PyObject *resultobj;
33936 wxMenu *arg1 = (wxMenu *) 0 ;
33937 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33938 bool result;
33939 PyObject * obj0 = 0 ;
33940 PyObject * obj1 = 0 ;
33941 char *kwnames[] = {
33942 (char *) "self",(char *) "item", NULL
33943 };
33944
33945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33947 if (SWIG_arg_fail(1)) SWIG_fail;
33948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33949 if (SWIG_arg_fail(2)) SWIG_fail;
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 result = (bool)(arg1)->Delete(arg2);
33953
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 {
33958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33959 }
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj;
33968 wxMenu *arg1 = (wxMenu *) 0 ;
33969 PyObject * obj0 = 0 ;
33970 char *kwnames[] = {
33971 (char *) "self", NULL
33972 };
33973
33974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33976 if (SWIG_arg_fail(1)) SWIG_fail;
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 wxMenu_Destroy(arg1);
33980
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 Py_INCREF(Py_None); resultobj = Py_None;
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33992 PyObject *resultobj;
33993 wxMenu *arg1 = (wxMenu *) 0 ;
33994 int arg2 ;
33995 bool result;
33996 PyObject * obj0 = 0 ;
33997 PyObject * obj1 = 0 ;
33998 char *kwnames[] = {
33999 (char *) "self",(char *) "id", NULL
34000 };
34001
34002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34004 if (SWIG_arg_fail(1)) SWIG_fail;
34005 {
34006 arg2 = (int)(SWIG_As_int(obj1));
34007 if (SWIG_arg_fail(2)) SWIG_fail;
34008 }
34009 {
34010 PyThreadState* __tstate = wxPyBeginAllowThreads();
34011 result = (bool)(arg1)->Destroy(arg2);
34012
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 {
34017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34018 }
34019 return resultobj;
34020 fail:
34021 return NULL;
34022 }
34023
34024
34025 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34026 PyObject *resultobj;
34027 wxMenu *arg1 = (wxMenu *) 0 ;
34028 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34029 bool result;
34030 PyObject * obj0 = 0 ;
34031 PyObject * obj1 = 0 ;
34032 char *kwnames[] = {
34033 (char *) "self",(char *) "item", NULL
34034 };
34035
34036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34038 if (SWIG_arg_fail(1)) SWIG_fail;
34039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34040 if (SWIG_arg_fail(2)) SWIG_fail;
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (bool)(arg1)->Destroy(arg2);
34044
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 {
34049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34050 }
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj;
34059 wxMenu *arg1 = (wxMenu *) 0 ;
34060 size_t result;
34061 PyObject * obj0 = 0 ;
34062 char *kwnames[] = {
34063 (char *) "self", NULL
34064 };
34065
34066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34068 if (SWIG_arg_fail(1)) SWIG_fail;
34069 {
34070 PyThreadState* __tstate = wxPyBeginAllowThreads();
34071 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34072
34073 wxPyEndAllowThreads(__tstate);
34074 if (PyErr_Occurred()) SWIG_fail;
34075 }
34076 {
34077 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34078 }
34079 return resultobj;
34080 fail:
34081 return NULL;
34082 }
34083
34084
34085 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34086 PyObject *resultobj;
34087 wxMenu *arg1 = (wxMenu *) 0 ;
34088 PyObject *result;
34089 PyObject * obj0 = 0 ;
34090 char *kwnames[] = {
34091 (char *) "self", NULL
34092 };
34093
34094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34096 if (SWIG_arg_fail(1)) SWIG_fail;
34097 {
34098 PyThreadState* __tstate = wxPyBeginAllowThreads();
34099 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34100
34101 wxPyEndAllowThreads(__tstate);
34102 if (PyErr_Occurred()) SWIG_fail;
34103 }
34104 resultobj = result;
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34112 PyObject *resultobj;
34113 wxMenu *arg1 = (wxMenu *) 0 ;
34114 wxString *arg2 = 0 ;
34115 int result;
34116 bool temp2 = false ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 char *kwnames[] = {
34120 (char *) "self",(char *) "item", NULL
34121 };
34122
34123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34125 if (SWIG_arg_fail(1)) SWIG_fail;
34126 {
34127 arg2 = wxString_in_helper(obj1);
34128 if (arg2 == NULL) SWIG_fail;
34129 temp2 = true;
34130 }
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34134
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 {
34139 resultobj = SWIG_From_int((int)(result));
34140 }
34141 {
34142 if (temp2)
34143 delete arg2;
34144 }
34145 return resultobj;
34146 fail:
34147 {
34148 if (temp2)
34149 delete arg2;
34150 }
34151 return NULL;
34152 }
34153
34154
34155 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj;
34157 wxMenu *arg1 = (wxMenu *) 0 ;
34158 int arg2 ;
34159 wxMenuItem *result;
34160 PyObject * obj0 = 0 ;
34161 PyObject * obj1 = 0 ;
34162 char *kwnames[] = {
34163 (char *) "self",(char *) "id", NULL
34164 };
34165
34166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34168 if (SWIG_arg_fail(1)) SWIG_fail;
34169 {
34170 arg2 = (int)(SWIG_As_int(obj1));
34171 if (SWIG_arg_fail(2)) SWIG_fail;
34172 }
34173 {
34174 PyThreadState* __tstate = wxPyBeginAllowThreads();
34175 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34176
34177 wxPyEndAllowThreads(__tstate);
34178 if (PyErr_Occurred()) SWIG_fail;
34179 }
34180 {
34181 resultobj = wxPyMake_wxObject(result, 0);
34182 }
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj;
34191 wxMenu *arg1 = (wxMenu *) 0 ;
34192 size_t arg2 ;
34193 wxMenuItem *result;
34194 PyObject * obj0 = 0 ;
34195 PyObject * obj1 = 0 ;
34196 char *kwnames[] = {
34197 (char *) "self",(char *) "position", NULL
34198 };
34199
34200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34202 if (SWIG_arg_fail(1)) SWIG_fail;
34203 {
34204 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34205 if (SWIG_arg_fail(2)) SWIG_fail;
34206 }
34207 {
34208 PyThreadState* __tstate = wxPyBeginAllowThreads();
34209 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34210
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 {
34215 resultobj = wxPyMake_wxObject(result, 0);
34216 }
34217 return resultobj;
34218 fail:
34219 return NULL;
34220 }
34221
34222
34223 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34224 PyObject *resultobj;
34225 wxMenu *arg1 = (wxMenu *) 0 ;
34226 int arg2 ;
34227 bool arg3 ;
34228 PyObject * obj0 = 0 ;
34229 PyObject * obj1 = 0 ;
34230 PyObject * obj2 = 0 ;
34231 char *kwnames[] = {
34232 (char *) "self",(char *) "id",(char *) "enable", NULL
34233 };
34234
34235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(1)) SWIG_fail;
34238 {
34239 arg2 = (int)(SWIG_As_int(obj1));
34240 if (SWIG_arg_fail(2)) SWIG_fail;
34241 }
34242 {
34243 arg3 = (bool)(SWIG_As_bool(obj2));
34244 if (SWIG_arg_fail(3)) SWIG_fail;
34245 }
34246 {
34247 PyThreadState* __tstate = wxPyBeginAllowThreads();
34248 (arg1)->Enable(arg2,arg3);
34249
34250 wxPyEndAllowThreads(__tstate);
34251 if (PyErr_Occurred()) SWIG_fail;
34252 }
34253 Py_INCREF(Py_None); resultobj = Py_None;
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34261 PyObject *resultobj;
34262 wxMenu *arg1 = (wxMenu *) 0 ;
34263 int arg2 ;
34264 bool result;
34265 PyObject * obj0 = 0 ;
34266 PyObject * obj1 = 0 ;
34267 char *kwnames[] = {
34268 (char *) "self",(char *) "id", NULL
34269 };
34270
34271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34273 if (SWIG_arg_fail(1)) SWIG_fail;
34274 {
34275 arg2 = (int)(SWIG_As_int(obj1));
34276 if (SWIG_arg_fail(2)) SWIG_fail;
34277 }
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34281
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 {
34286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34287 }
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj;
34296 wxMenu *arg1 = (wxMenu *) 0 ;
34297 int arg2 ;
34298 bool arg3 ;
34299 PyObject * obj0 = 0 ;
34300 PyObject * obj1 = 0 ;
34301 PyObject * obj2 = 0 ;
34302 char *kwnames[] = {
34303 (char *) "self",(char *) "id",(char *) "check", NULL
34304 };
34305
34306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34308 if (SWIG_arg_fail(1)) SWIG_fail;
34309 {
34310 arg2 = (int)(SWIG_As_int(obj1));
34311 if (SWIG_arg_fail(2)) SWIG_fail;
34312 }
34313 {
34314 arg3 = (bool)(SWIG_As_bool(obj2));
34315 if (SWIG_arg_fail(3)) SWIG_fail;
34316 }
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 (arg1)->Check(arg2,arg3);
34320
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 Py_INCREF(Py_None); resultobj = Py_None;
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj;
34333 wxMenu *arg1 = (wxMenu *) 0 ;
34334 int arg2 ;
34335 bool result;
34336 PyObject * obj0 = 0 ;
34337 PyObject * obj1 = 0 ;
34338 char *kwnames[] = {
34339 (char *) "self",(char *) "id", NULL
34340 };
34341
34342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34344 if (SWIG_arg_fail(1)) SWIG_fail;
34345 {
34346 arg2 = (int)(SWIG_As_int(obj1));
34347 if (SWIG_arg_fail(2)) SWIG_fail;
34348 }
34349 {
34350 PyThreadState* __tstate = wxPyBeginAllowThreads();
34351 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34352
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 {
34357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34358 }
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34366 PyObject *resultobj;
34367 wxMenu *arg1 = (wxMenu *) 0 ;
34368 int arg2 ;
34369 wxString *arg3 = 0 ;
34370 bool temp3 = false ;
34371 PyObject * obj0 = 0 ;
34372 PyObject * obj1 = 0 ;
34373 PyObject * obj2 = 0 ;
34374 char *kwnames[] = {
34375 (char *) "self",(char *) "id",(char *) "label", NULL
34376 };
34377
34378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(1)) SWIG_fail;
34381 {
34382 arg2 = (int)(SWIG_As_int(obj1));
34383 if (SWIG_arg_fail(2)) SWIG_fail;
34384 }
34385 {
34386 arg3 = wxString_in_helper(obj2);
34387 if (arg3 == NULL) SWIG_fail;
34388 temp3 = true;
34389 }
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34393
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 Py_INCREF(Py_None); resultobj = Py_None;
34398 {
34399 if (temp3)
34400 delete arg3;
34401 }
34402 return resultobj;
34403 fail:
34404 {
34405 if (temp3)
34406 delete arg3;
34407 }
34408 return NULL;
34409 }
34410
34411
34412 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34413 PyObject *resultobj;
34414 wxMenu *arg1 = (wxMenu *) 0 ;
34415 int arg2 ;
34416 wxString result;
34417 PyObject * obj0 = 0 ;
34418 PyObject * obj1 = 0 ;
34419 char *kwnames[] = {
34420 (char *) "self",(char *) "id", NULL
34421 };
34422
34423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34425 if (SWIG_arg_fail(1)) SWIG_fail;
34426 {
34427 arg2 = (int)(SWIG_As_int(obj1));
34428 if (SWIG_arg_fail(2)) SWIG_fail;
34429 }
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34433
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 #if wxUSE_UNICODE
34439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34440 #else
34441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34442 #endif
34443 }
34444 return resultobj;
34445 fail:
34446 return NULL;
34447 }
34448
34449
34450 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34451 PyObject *resultobj;
34452 wxMenu *arg1 = (wxMenu *) 0 ;
34453 int arg2 ;
34454 wxString *arg3 = 0 ;
34455 bool temp3 = false ;
34456 PyObject * obj0 = 0 ;
34457 PyObject * obj1 = 0 ;
34458 PyObject * obj2 = 0 ;
34459 char *kwnames[] = {
34460 (char *) "self",(char *) "id",(char *) "helpString", NULL
34461 };
34462
34463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34465 if (SWIG_arg_fail(1)) SWIG_fail;
34466 {
34467 arg2 = (int)(SWIG_As_int(obj1));
34468 if (SWIG_arg_fail(2)) SWIG_fail;
34469 }
34470 {
34471 arg3 = wxString_in_helper(obj2);
34472 if (arg3 == NULL) SWIG_fail;
34473 temp3 = true;
34474 }
34475 {
34476 PyThreadState* __tstate = wxPyBeginAllowThreads();
34477 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34478
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 Py_INCREF(Py_None); resultobj = Py_None;
34483 {
34484 if (temp3)
34485 delete arg3;
34486 }
34487 return resultobj;
34488 fail:
34489 {
34490 if (temp3)
34491 delete arg3;
34492 }
34493 return NULL;
34494 }
34495
34496
34497 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34498 PyObject *resultobj;
34499 wxMenu *arg1 = (wxMenu *) 0 ;
34500 int arg2 ;
34501 wxString result;
34502 PyObject * obj0 = 0 ;
34503 PyObject * obj1 = 0 ;
34504 char *kwnames[] = {
34505 (char *) "self",(char *) "id", NULL
34506 };
34507
34508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34510 if (SWIG_arg_fail(1)) SWIG_fail;
34511 {
34512 arg2 = (int)(SWIG_As_int(obj1));
34513 if (SWIG_arg_fail(2)) SWIG_fail;
34514 }
34515 {
34516 PyThreadState* __tstate = wxPyBeginAllowThreads();
34517 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34518
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 {
34523 #if wxUSE_UNICODE
34524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34525 #else
34526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34527 #endif
34528 }
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj;
34537 wxMenu *arg1 = (wxMenu *) 0 ;
34538 wxString *arg2 = 0 ;
34539 bool temp2 = false ;
34540 PyObject * obj0 = 0 ;
34541 PyObject * obj1 = 0 ;
34542 char *kwnames[] = {
34543 (char *) "self",(char *) "title", NULL
34544 };
34545
34546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34548 if (SWIG_arg_fail(1)) SWIG_fail;
34549 {
34550 arg2 = wxString_in_helper(obj1);
34551 if (arg2 == NULL) SWIG_fail;
34552 temp2 = true;
34553 }
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 (arg1)->SetTitle((wxString const &)*arg2);
34557
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 Py_INCREF(Py_None); resultobj = Py_None;
34562 {
34563 if (temp2)
34564 delete arg2;
34565 }
34566 return resultobj;
34567 fail:
34568 {
34569 if (temp2)
34570 delete arg2;
34571 }
34572 return NULL;
34573 }
34574
34575
34576 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34577 PyObject *resultobj;
34578 wxMenu *arg1 = (wxMenu *) 0 ;
34579 wxString result;
34580 PyObject * obj0 = 0 ;
34581 char *kwnames[] = {
34582 (char *) "self", NULL
34583 };
34584
34585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34587 if (SWIG_arg_fail(1)) SWIG_fail;
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 result = ((wxMenu const *)arg1)->GetTitle();
34591
34592 wxPyEndAllowThreads(__tstate);
34593 if (PyErr_Occurred()) SWIG_fail;
34594 }
34595 {
34596 #if wxUSE_UNICODE
34597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34598 #else
34599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34600 #endif
34601 }
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj;
34610 wxMenu *arg1 = (wxMenu *) 0 ;
34611 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 char *kwnames[] = {
34615 (char *) "self",(char *) "handler", NULL
34616 };
34617
34618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34620 if (SWIG_arg_fail(1)) SWIG_fail;
34621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34622 if (SWIG_arg_fail(2)) SWIG_fail;
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 (arg1)->SetEventHandler(arg2);
34626
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 Py_INCREF(Py_None); resultobj = Py_None;
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj;
34639 wxMenu *arg1 = (wxMenu *) 0 ;
34640 wxEvtHandler *result;
34641 PyObject * obj0 = 0 ;
34642 char *kwnames[] = {
34643 (char *) "self", NULL
34644 };
34645
34646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34648 if (SWIG_arg_fail(1)) SWIG_fail;
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34652
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 {
34657 resultobj = wxPyMake_wxObject(result, 0);
34658 }
34659 return resultobj;
34660 fail:
34661 return NULL;
34662 }
34663
34664
34665 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34666 PyObject *resultobj;
34667 wxMenu *arg1 = (wxMenu *) 0 ;
34668 wxWindow *arg2 = (wxWindow *) 0 ;
34669 PyObject * obj0 = 0 ;
34670 PyObject * obj1 = 0 ;
34671 char *kwnames[] = {
34672 (char *) "self",(char *) "win", NULL
34673 };
34674
34675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34677 if (SWIG_arg_fail(1)) SWIG_fail;
34678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34679 if (SWIG_arg_fail(2)) SWIG_fail;
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 (arg1)->SetInvokingWindow(arg2);
34683
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 Py_INCREF(Py_None); resultobj = Py_None;
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj;
34696 wxMenu *arg1 = (wxMenu *) 0 ;
34697 wxWindow *result;
34698 PyObject * obj0 = 0 ;
34699 char *kwnames[] = {
34700 (char *) "self", NULL
34701 };
34702
34703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34705 if (SWIG_arg_fail(1)) SWIG_fail;
34706 {
34707 PyThreadState* __tstate = wxPyBeginAllowThreads();
34708 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34709
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 {
34714 resultobj = wxPyMake_wxObject(result, 0);
34715 }
34716 return resultobj;
34717 fail:
34718 return NULL;
34719 }
34720
34721
34722 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34723 PyObject *resultobj;
34724 wxMenu *arg1 = (wxMenu *) 0 ;
34725 long result;
34726 PyObject * obj0 = 0 ;
34727 char *kwnames[] = {
34728 (char *) "self", NULL
34729 };
34730
34731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34733 if (SWIG_arg_fail(1)) SWIG_fail;
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (long)((wxMenu const *)arg1)->GetStyle();
34737
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = SWIG_From_long((long)(result));
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj;
34752 wxMenu *arg1 = (wxMenu *) 0 ;
34753 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34754 PyObject * obj0 = 0 ;
34755 PyObject * obj1 = 0 ;
34756 char *kwnames[] = {
34757 (char *) "self",(char *) "source", NULL
34758 };
34759
34760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34762 if (SWIG_arg_fail(1)) SWIG_fail;
34763 if (obj1) {
34764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34765 if (SWIG_arg_fail(2)) SWIG_fail;
34766 }
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 (arg1)->UpdateUI(arg2);
34770
34771 wxPyEndAllowThreads(__tstate);
34772 if (PyErr_Occurred()) SWIG_fail;
34773 }
34774 Py_INCREF(Py_None); resultobj = Py_None;
34775 return resultobj;
34776 fail:
34777 return NULL;
34778 }
34779
34780
34781 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34782 PyObject *resultobj;
34783 wxMenu *arg1 = (wxMenu *) 0 ;
34784 wxMenuBar *result;
34785 PyObject * obj0 = 0 ;
34786 char *kwnames[] = {
34787 (char *) "self", NULL
34788 };
34789
34790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34792 if (SWIG_arg_fail(1)) SWIG_fail;
34793 {
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34796
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 {
34801 resultobj = wxPyMake_wxObject(result, 0);
34802 }
34803 return resultobj;
34804 fail:
34805 return NULL;
34806 }
34807
34808
34809 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34810 PyObject *resultobj;
34811 wxMenu *arg1 = (wxMenu *) 0 ;
34812 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34813 PyObject * obj0 = 0 ;
34814 PyObject * obj1 = 0 ;
34815 char *kwnames[] = {
34816 (char *) "self",(char *) "menubar", NULL
34817 };
34818
34819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34821 if (SWIG_arg_fail(1)) SWIG_fail;
34822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34823 if (SWIG_arg_fail(2)) SWIG_fail;
34824 {
34825 PyThreadState* __tstate = wxPyBeginAllowThreads();
34826 (arg1)->Attach(arg2);
34827
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 Py_INCREF(Py_None); resultobj = Py_None;
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj;
34840 wxMenu *arg1 = (wxMenu *) 0 ;
34841 PyObject * obj0 = 0 ;
34842 char *kwnames[] = {
34843 (char *) "self", NULL
34844 };
34845
34846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34848 if (SWIG_arg_fail(1)) SWIG_fail;
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 (arg1)->Detach();
34852
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 Py_INCREF(Py_None); resultobj = Py_None;
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj;
34865 wxMenu *arg1 = (wxMenu *) 0 ;
34866 bool result;
34867 PyObject * obj0 = 0 ;
34868 char *kwnames[] = {
34869 (char *) "self", NULL
34870 };
34871
34872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34874 if (SWIG_arg_fail(1)) SWIG_fail;
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 result = (bool)((wxMenu const *)arg1)->IsAttached();
34878
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj;
34893 wxMenu *arg1 = (wxMenu *) 0 ;
34894 wxMenu *arg2 = (wxMenu *) 0 ;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 char *kwnames[] = {
34898 (char *) "self",(char *) "parent", NULL
34899 };
34900
34901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34903 if (SWIG_arg_fail(1)) SWIG_fail;
34904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34905 if (SWIG_arg_fail(2)) SWIG_fail;
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 (arg1)->SetParent(arg2);
34909
34910 wxPyEndAllowThreads(__tstate);
34911 if (PyErr_Occurred()) SWIG_fail;
34912 }
34913 Py_INCREF(Py_None); resultobj = Py_None;
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34921 PyObject *resultobj;
34922 wxMenu *arg1 = (wxMenu *) 0 ;
34923 wxMenu *result;
34924 PyObject * obj0 = 0 ;
34925 char *kwnames[] = {
34926 (char *) "self", NULL
34927 };
34928
34929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34931 if (SWIG_arg_fail(1)) SWIG_fail;
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34935
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 resultobj = wxPyMake_wxObject(result, 0);
34941 }
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34949 PyObject *obj;
34950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34951 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34952 Py_INCREF(obj);
34953 return Py_BuildValue((char *)"");
34954 }
34955 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34956 PyObject *resultobj;
34957 long arg1 = (long) 0 ;
34958 wxMenuBar *result;
34959 PyObject * obj0 = 0 ;
34960 char *kwnames[] = {
34961 (char *) "style", NULL
34962 };
34963
34964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34965 if (obj0) {
34966 {
34967 arg1 = (long)(SWIG_As_long(obj0));
34968 if (SWIG_arg_fail(1)) SWIG_fail;
34969 }
34970 }
34971 {
34972 if (!wxPyCheckForApp()) SWIG_fail;
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = (wxMenuBar *)new wxMenuBar(arg1);
34975
34976 wxPyEndAllowThreads(__tstate);
34977 if (PyErr_Occurred()) SWIG_fail;
34978 }
34979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34987 PyObject *resultobj;
34988 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34989 wxMenu *arg2 = (wxMenu *) 0 ;
34990 wxString *arg3 = 0 ;
34991 bool result;
34992 bool temp3 = false ;
34993 PyObject * obj0 = 0 ;
34994 PyObject * obj1 = 0 ;
34995 PyObject * obj2 = 0 ;
34996 char *kwnames[] = {
34997 (char *) "self",(char *) "menu",(char *) "title", NULL
34998 };
34999
35000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35002 if (SWIG_arg_fail(1)) SWIG_fail;
35003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35004 if (SWIG_arg_fail(2)) SWIG_fail;
35005 {
35006 arg3 = wxString_in_helper(obj2);
35007 if (arg3 == NULL) SWIG_fail;
35008 temp3 = true;
35009 }
35010 {
35011 PyThreadState* __tstate = wxPyBeginAllowThreads();
35012 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35013
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 {
35018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35019 }
35020 {
35021 if (temp3)
35022 delete arg3;
35023 }
35024 return resultobj;
35025 fail:
35026 {
35027 if (temp3)
35028 delete arg3;
35029 }
35030 return NULL;
35031 }
35032
35033
35034 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35035 PyObject *resultobj;
35036 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35037 size_t arg2 ;
35038 wxMenu *arg3 = (wxMenu *) 0 ;
35039 wxString *arg4 = 0 ;
35040 bool result;
35041 bool temp4 = false ;
35042 PyObject * obj0 = 0 ;
35043 PyObject * obj1 = 0 ;
35044 PyObject * obj2 = 0 ;
35045 PyObject * obj3 = 0 ;
35046 char *kwnames[] = {
35047 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35048 };
35049
35050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35052 if (SWIG_arg_fail(1)) SWIG_fail;
35053 {
35054 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35055 if (SWIG_arg_fail(2)) SWIG_fail;
35056 }
35057 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35058 if (SWIG_arg_fail(3)) SWIG_fail;
35059 {
35060 arg4 = wxString_in_helper(obj3);
35061 if (arg4 == NULL) SWIG_fail;
35062 temp4 = true;
35063 }
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35067
35068 wxPyEndAllowThreads(__tstate);
35069 if (PyErr_Occurred()) SWIG_fail;
35070 }
35071 {
35072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35073 }
35074 {
35075 if (temp4)
35076 delete arg4;
35077 }
35078 return resultobj;
35079 fail:
35080 {
35081 if (temp4)
35082 delete arg4;
35083 }
35084 return NULL;
35085 }
35086
35087
35088 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35089 PyObject *resultobj;
35090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35091 size_t result;
35092 PyObject * obj0 = 0 ;
35093 char *kwnames[] = {
35094 (char *) "self", NULL
35095 };
35096
35097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35099 if (SWIG_arg_fail(1)) SWIG_fail;
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35103
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 {
35108 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35109 }
35110 return resultobj;
35111 fail:
35112 return NULL;
35113 }
35114
35115
35116 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35117 PyObject *resultobj;
35118 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35119 size_t arg2 ;
35120 wxMenu *result;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char *kwnames[] = {
35124 (char *) "self",(char *) "pos", NULL
35125 };
35126
35127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35129 if (SWIG_arg_fail(1)) SWIG_fail;
35130 {
35131 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35132 if (SWIG_arg_fail(2)) SWIG_fail;
35133 }
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35137
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 {
35142 resultobj = wxPyMake_wxObject(result, 0);
35143 }
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj;
35152 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35153 size_t arg2 ;
35154 wxMenu *arg3 = (wxMenu *) 0 ;
35155 wxString *arg4 = 0 ;
35156 wxMenu *result;
35157 bool temp4 = false ;
35158 PyObject * obj0 = 0 ;
35159 PyObject * obj1 = 0 ;
35160 PyObject * obj2 = 0 ;
35161 PyObject * obj3 = 0 ;
35162 char *kwnames[] = {
35163 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35164 };
35165
35166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35168 if (SWIG_arg_fail(1)) SWIG_fail;
35169 {
35170 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35171 if (SWIG_arg_fail(2)) SWIG_fail;
35172 }
35173 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35174 if (SWIG_arg_fail(3)) SWIG_fail;
35175 {
35176 arg4 = wxString_in_helper(obj3);
35177 if (arg4 == NULL) SWIG_fail;
35178 temp4 = true;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 resultobj = wxPyMake_wxObject(result, 0);
35189 }
35190 {
35191 if (temp4)
35192 delete arg4;
35193 }
35194 return resultobj;
35195 fail:
35196 {
35197 if (temp4)
35198 delete arg4;
35199 }
35200 return NULL;
35201 }
35202
35203
35204 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35205 PyObject *resultobj;
35206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35207 size_t arg2 ;
35208 wxMenu *result;
35209 PyObject * obj0 = 0 ;
35210 PyObject * obj1 = 0 ;
35211 char *kwnames[] = {
35212 (char *) "self",(char *) "pos", NULL
35213 };
35214
35215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35217 if (SWIG_arg_fail(1)) SWIG_fail;
35218 {
35219 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35220 if (SWIG_arg_fail(2)) SWIG_fail;
35221 }
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 result = (wxMenu *)(arg1)->Remove(arg2);
35225
35226 wxPyEndAllowThreads(__tstate);
35227 if (PyErr_Occurred()) SWIG_fail;
35228 }
35229 {
35230 resultobj = wxPyMake_wxObject(result, 0);
35231 }
35232 return resultobj;
35233 fail:
35234 return NULL;
35235 }
35236
35237
35238 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35239 PyObject *resultobj;
35240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35241 size_t arg2 ;
35242 bool arg3 ;
35243 PyObject * obj0 = 0 ;
35244 PyObject * obj1 = 0 ;
35245 PyObject * obj2 = 0 ;
35246 char *kwnames[] = {
35247 (char *) "self",(char *) "pos",(char *) "enable", NULL
35248 };
35249
35250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35252 if (SWIG_arg_fail(1)) SWIG_fail;
35253 {
35254 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35255 if (SWIG_arg_fail(2)) SWIG_fail;
35256 }
35257 {
35258 arg3 = (bool)(SWIG_As_bool(obj2));
35259 if (SWIG_arg_fail(3)) SWIG_fail;
35260 }
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 (arg1)->EnableTop(arg2,arg3);
35264
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 Py_INCREF(Py_None); resultobj = Py_None;
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj;
35277 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35278 size_t arg2 ;
35279 bool result;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 char *kwnames[] = {
35283 (char *) "self",(char *) "pos", NULL
35284 };
35285
35286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35288 if (SWIG_arg_fail(1)) SWIG_fail;
35289 {
35290 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35291 if (SWIG_arg_fail(2)) SWIG_fail;
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35296
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 {
35301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35302 }
35303 return resultobj;
35304 fail:
35305 return NULL;
35306 }
35307
35308
35309 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35310 PyObject *resultobj;
35311 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35312 size_t arg2 ;
35313 wxString *arg3 = 0 ;
35314 bool temp3 = false ;
35315 PyObject * obj0 = 0 ;
35316 PyObject * obj1 = 0 ;
35317 PyObject * obj2 = 0 ;
35318 char *kwnames[] = {
35319 (char *) "self",(char *) "pos",(char *) "label", NULL
35320 };
35321
35322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35324 if (SWIG_arg_fail(1)) SWIG_fail;
35325 {
35326 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35327 if (SWIG_arg_fail(2)) SWIG_fail;
35328 }
35329 {
35330 arg3 = wxString_in_helper(obj2);
35331 if (arg3 == NULL) SWIG_fail;
35332 temp3 = true;
35333 }
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35337
35338 wxPyEndAllowThreads(__tstate);
35339 if (PyErr_Occurred()) SWIG_fail;
35340 }
35341 Py_INCREF(Py_None); resultobj = Py_None;
35342 {
35343 if (temp3)
35344 delete arg3;
35345 }
35346 return resultobj;
35347 fail:
35348 {
35349 if (temp3)
35350 delete arg3;
35351 }
35352 return NULL;
35353 }
35354
35355
35356 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35357 PyObject *resultobj;
35358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35359 size_t arg2 ;
35360 wxString result;
35361 PyObject * obj0 = 0 ;
35362 PyObject * obj1 = 0 ;
35363 char *kwnames[] = {
35364 (char *) "self",(char *) "pos", NULL
35365 };
35366
35367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35369 if (SWIG_arg_fail(1)) SWIG_fail;
35370 {
35371 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35372 if (SWIG_arg_fail(2)) SWIG_fail;
35373 }
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35377
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 {
35382 #if wxUSE_UNICODE
35383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35384 #else
35385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35386 #endif
35387 }
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj;
35396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35397 wxString *arg2 = 0 ;
35398 wxString *arg3 = 0 ;
35399 int result;
35400 bool temp2 = false ;
35401 bool temp3 = false ;
35402 PyObject * obj0 = 0 ;
35403 PyObject * obj1 = 0 ;
35404 PyObject * obj2 = 0 ;
35405 char *kwnames[] = {
35406 (char *) "self",(char *) "menu",(char *) "item", NULL
35407 };
35408
35409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 {
35413 arg2 = wxString_in_helper(obj1);
35414 if (arg2 == NULL) SWIG_fail;
35415 temp2 = true;
35416 }
35417 {
35418 arg3 = wxString_in_helper(obj2);
35419 if (arg3 == NULL) SWIG_fail;
35420 temp3 = true;
35421 }
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35425
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 {
35430 resultobj = SWIG_From_int((int)(result));
35431 }
35432 {
35433 if (temp2)
35434 delete arg2;
35435 }
35436 {
35437 if (temp3)
35438 delete arg3;
35439 }
35440 return resultobj;
35441 fail:
35442 {
35443 if (temp2)
35444 delete arg2;
35445 }
35446 {
35447 if (temp3)
35448 delete arg3;
35449 }
35450 return NULL;
35451 }
35452
35453
35454 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35455 PyObject *resultobj;
35456 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35457 int arg2 ;
35458 wxMenuItem *result;
35459 PyObject * obj0 = 0 ;
35460 PyObject * obj1 = 0 ;
35461 char *kwnames[] = {
35462 (char *) "self",(char *) "id", NULL
35463 };
35464
35465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35467 if (SWIG_arg_fail(1)) SWIG_fail;
35468 {
35469 arg2 = (int)(SWIG_As_int(obj1));
35470 if (SWIG_arg_fail(2)) SWIG_fail;
35471 }
35472 {
35473 PyThreadState* __tstate = wxPyBeginAllowThreads();
35474 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35475
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 resultobj = wxPyMake_wxObject(result, 0);
35481 }
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj;
35490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35491 wxString *arg2 = 0 ;
35492 int result;
35493 bool temp2 = false ;
35494 PyObject * obj0 = 0 ;
35495 PyObject * obj1 = 0 ;
35496 char *kwnames[] = {
35497 (char *) "self",(char *) "title", NULL
35498 };
35499
35500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35502 if (SWIG_arg_fail(1)) SWIG_fail;
35503 {
35504 arg2 = wxString_in_helper(obj1);
35505 if (arg2 == NULL) SWIG_fail;
35506 temp2 = true;
35507 }
35508 {
35509 PyThreadState* __tstate = wxPyBeginAllowThreads();
35510 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35511
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 {
35516 resultobj = SWIG_From_int((int)(result));
35517 }
35518 {
35519 if (temp2)
35520 delete arg2;
35521 }
35522 return resultobj;
35523 fail:
35524 {
35525 if (temp2)
35526 delete arg2;
35527 }
35528 return NULL;
35529 }
35530
35531
35532 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35533 PyObject *resultobj;
35534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35535 int arg2 ;
35536 bool arg3 ;
35537 PyObject * obj0 = 0 ;
35538 PyObject * obj1 = 0 ;
35539 PyObject * obj2 = 0 ;
35540 char *kwnames[] = {
35541 (char *) "self",(char *) "id",(char *) "enable", NULL
35542 };
35543
35544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35546 if (SWIG_arg_fail(1)) SWIG_fail;
35547 {
35548 arg2 = (int)(SWIG_As_int(obj1));
35549 if (SWIG_arg_fail(2)) SWIG_fail;
35550 }
35551 {
35552 arg3 = (bool)(SWIG_As_bool(obj2));
35553 if (SWIG_arg_fail(3)) SWIG_fail;
35554 }
35555 {
35556 PyThreadState* __tstate = wxPyBeginAllowThreads();
35557 (arg1)->Enable(arg2,arg3);
35558
35559 wxPyEndAllowThreads(__tstate);
35560 if (PyErr_Occurred()) SWIG_fail;
35561 }
35562 Py_INCREF(Py_None); resultobj = Py_None;
35563 return resultobj;
35564 fail:
35565 return NULL;
35566 }
35567
35568
35569 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj;
35571 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35572 int arg2 ;
35573 bool arg3 ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 PyObject * obj2 = 0 ;
35577 char *kwnames[] = {
35578 (char *) "self",(char *) "id",(char *) "check", NULL
35579 };
35580
35581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35583 if (SWIG_arg_fail(1)) SWIG_fail;
35584 {
35585 arg2 = (int)(SWIG_As_int(obj1));
35586 if (SWIG_arg_fail(2)) SWIG_fail;
35587 }
35588 {
35589 arg3 = (bool)(SWIG_As_bool(obj2));
35590 if (SWIG_arg_fail(3)) SWIG_fail;
35591 }
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 (arg1)->Check(arg2,arg3);
35595
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 Py_INCREF(Py_None); resultobj = Py_None;
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj;
35608 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35609 int arg2 ;
35610 bool result;
35611 PyObject * obj0 = 0 ;
35612 PyObject * obj1 = 0 ;
35613 char *kwnames[] = {
35614 (char *) "self",(char *) "id", NULL
35615 };
35616
35617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35619 if (SWIG_arg_fail(1)) SWIG_fail;
35620 {
35621 arg2 = (int)(SWIG_As_int(obj1));
35622 if (SWIG_arg_fail(2)) SWIG_fail;
35623 }
35624 {
35625 PyThreadState* __tstate = wxPyBeginAllowThreads();
35626 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35627
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 {
35632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35633 }
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35641 PyObject *resultobj;
35642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35643 int arg2 ;
35644 bool result;
35645 PyObject * obj0 = 0 ;
35646 PyObject * obj1 = 0 ;
35647 char *kwnames[] = {
35648 (char *) "self",(char *) "id", NULL
35649 };
35650
35651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35653 if (SWIG_arg_fail(1)) SWIG_fail;
35654 {
35655 arg2 = (int)(SWIG_As_int(obj1));
35656 if (SWIG_arg_fail(2)) SWIG_fail;
35657 }
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35661
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 {
35666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35667 }
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35675 PyObject *resultobj;
35676 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35677 int arg2 ;
35678 wxString *arg3 = 0 ;
35679 bool temp3 = false ;
35680 PyObject * obj0 = 0 ;
35681 PyObject * obj1 = 0 ;
35682 PyObject * obj2 = 0 ;
35683 char *kwnames[] = {
35684 (char *) "self",(char *) "id",(char *) "label", NULL
35685 };
35686
35687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35689 if (SWIG_arg_fail(1)) SWIG_fail;
35690 {
35691 arg2 = (int)(SWIG_As_int(obj1));
35692 if (SWIG_arg_fail(2)) SWIG_fail;
35693 }
35694 {
35695 arg3 = wxString_in_helper(obj2);
35696 if (arg3 == NULL) SWIG_fail;
35697 temp3 = true;
35698 }
35699 {
35700 PyThreadState* __tstate = wxPyBeginAllowThreads();
35701 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35702
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 Py_INCREF(Py_None); resultobj = Py_None;
35707 {
35708 if (temp3)
35709 delete arg3;
35710 }
35711 return resultobj;
35712 fail:
35713 {
35714 if (temp3)
35715 delete arg3;
35716 }
35717 return NULL;
35718 }
35719
35720
35721 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35722 PyObject *resultobj;
35723 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35724 int arg2 ;
35725 wxString result;
35726 PyObject * obj0 = 0 ;
35727 PyObject * obj1 = 0 ;
35728 char *kwnames[] = {
35729 (char *) "self",(char *) "id", NULL
35730 };
35731
35732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35734 if (SWIG_arg_fail(1)) SWIG_fail;
35735 {
35736 arg2 = (int)(SWIG_As_int(obj1));
35737 if (SWIG_arg_fail(2)) SWIG_fail;
35738 }
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35742
35743 wxPyEndAllowThreads(__tstate);
35744 if (PyErr_Occurred()) SWIG_fail;
35745 }
35746 {
35747 #if wxUSE_UNICODE
35748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35749 #else
35750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35751 #endif
35752 }
35753 return resultobj;
35754 fail:
35755 return NULL;
35756 }
35757
35758
35759 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35760 PyObject *resultobj;
35761 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35762 int arg2 ;
35763 wxString *arg3 = 0 ;
35764 bool temp3 = false ;
35765 PyObject * obj0 = 0 ;
35766 PyObject * obj1 = 0 ;
35767 PyObject * obj2 = 0 ;
35768 char *kwnames[] = {
35769 (char *) "self",(char *) "id",(char *) "helpString", NULL
35770 };
35771
35772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35774 if (SWIG_arg_fail(1)) SWIG_fail;
35775 {
35776 arg2 = (int)(SWIG_As_int(obj1));
35777 if (SWIG_arg_fail(2)) SWIG_fail;
35778 }
35779 {
35780 arg3 = wxString_in_helper(obj2);
35781 if (arg3 == NULL) SWIG_fail;
35782 temp3 = true;
35783 }
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35787
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 Py_INCREF(Py_None); resultobj = Py_None;
35792 {
35793 if (temp3)
35794 delete arg3;
35795 }
35796 return resultobj;
35797 fail:
35798 {
35799 if (temp3)
35800 delete arg3;
35801 }
35802 return NULL;
35803 }
35804
35805
35806 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35807 PyObject *resultobj;
35808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35809 int arg2 ;
35810 wxString result;
35811 PyObject * obj0 = 0 ;
35812 PyObject * obj1 = 0 ;
35813 char *kwnames[] = {
35814 (char *) "self",(char *) "id", NULL
35815 };
35816
35817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35819 if (SWIG_arg_fail(1)) SWIG_fail;
35820 {
35821 arg2 = (int)(SWIG_As_int(obj1));
35822 if (SWIG_arg_fail(2)) SWIG_fail;
35823 }
35824 {
35825 PyThreadState* __tstate = wxPyBeginAllowThreads();
35826 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35827
35828 wxPyEndAllowThreads(__tstate);
35829 if (PyErr_Occurred()) SWIG_fail;
35830 }
35831 {
35832 #if wxUSE_UNICODE
35833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35834 #else
35835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35836 #endif
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35845 PyObject *resultobj;
35846 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35847 wxFrame *result;
35848 PyObject * obj0 = 0 ;
35849 char *kwnames[] = {
35850 (char *) "self", NULL
35851 };
35852
35853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35855 if (SWIG_arg_fail(1)) SWIG_fail;
35856 {
35857 PyThreadState* __tstate = wxPyBeginAllowThreads();
35858 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35859
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 {
35864 resultobj = wxPyMake_wxObject(result, 0);
35865 }
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj;
35874 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35875 bool result;
35876 PyObject * obj0 = 0 ;
35877 char *kwnames[] = {
35878 (char *) "self", NULL
35879 };
35880
35881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35883 if (SWIG_arg_fail(1)) SWIG_fail;
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35887
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 {
35892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35893 }
35894 return resultobj;
35895 fail:
35896 return NULL;
35897 }
35898
35899
35900 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj;
35902 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35903 wxFrame *arg2 = (wxFrame *) 0 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 char *kwnames[] = {
35907 (char *) "self",(char *) "frame", NULL
35908 };
35909
35910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35912 if (SWIG_arg_fail(1)) SWIG_fail;
35913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35914 if (SWIG_arg_fail(2)) SWIG_fail;
35915 {
35916 PyThreadState* __tstate = wxPyBeginAllowThreads();
35917 (arg1)->Attach(arg2);
35918
35919 wxPyEndAllowThreads(__tstate);
35920 if (PyErr_Occurred()) SWIG_fail;
35921 }
35922 Py_INCREF(Py_None); resultobj = Py_None;
35923 return resultobj;
35924 fail:
35925 return NULL;
35926 }
35927
35928
35929 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35930 PyObject *resultobj;
35931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35932 PyObject * obj0 = 0 ;
35933 char *kwnames[] = {
35934 (char *) "self", NULL
35935 };
35936
35937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35939 if (SWIG_arg_fail(1)) SWIG_fail;
35940 {
35941 PyThreadState* __tstate = wxPyBeginAllowThreads();
35942 (arg1)->Detach();
35943
35944 wxPyEndAllowThreads(__tstate);
35945 if (PyErr_Occurred()) SWIG_fail;
35946 }
35947 Py_INCREF(Py_None); resultobj = Py_None;
35948 return resultobj;
35949 fail:
35950 return NULL;
35951 }
35952
35953
35954 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35955 PyObject *obj;
35956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35957 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35958 Py_INCREF(obj);
35959 return Py_BuildValue((char *)"");
35960 }
35961 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35962 PyObject *resultobj;
35963 wxMenu *arg1 = (wxMenu *) NULL ;
35964 int arg2 = (int) wxID_ANY ;
35965 wxString const &arg3_defvalue = wxPyEmptyString ;
35966 wxString *arg3 = (wxString *) &arg3_defvalue ;
35967 wxString const &arg4_defvalue = wxPyEmptyString ;
35968 wxString *arg4 = (wxString *) &arg4_defvalue ;
35969 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35970 wxMenu *arg6 = (wxMenu *) NULL ;
35971 wxMenuItem *result;
35972 bool temp3 = false ;
35973 bool temp4 = false ;
35974 PyObject * obj0 = 0 ;
35975 PyObject * obj1 = 0 ;
35976 PyObject * obj2 = 0 ;
35977 PyObject * obj3 = 0 ;
35978 PyObject * obj4 = 0 ;
35979 PyObject * obj5 = 0 ;
35980 char *kwnames[] = {
35981 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35982 };
35983
35984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35985 if (obj0) {
35986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35987 if (SWIG_arg_fail(1)) SWIG_fail;
35988 }
35989 if (obj1) {
35990 {
35991 arg2 = (int)(SWIG_As_int(obj1));
35992 if (SWIG_arg_fail(2)) SWIG_fail;
35993 }
35994 }
35995 if (obj2) {
35996 {
35997 arg3 = wxString_in_helper(obj2);
35998 if (arg3 == NULL) SWIG_fail;
35999 temp3 = true;
36000 }
36001 }
36002 if (obj3) {
36003 {
36004 arg4 = wxString_in_helper(obj3);
36005 if (arg4 == NULL) SWIG_fail;
36006 temp4 = true;
36007 }
36008 }
36009 if (obj4) {
36010 {
36011 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36012 if (SWIG_arg_fail(5)) SWIG_fail;
36013 }
36014 }
36015 if (obj5) {
36016 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36017 if (SWIG_arg_fail(6)) SWIG_fail;
36018 }
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36022
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 {
36027 resultobj = wxPyMake_wxObject(result, 1);
36028 }
36029 {
36030 if (temp3)
36031 delete arg3;
36032 }
36033 {
36034 if (temp4)
36035 delete arg4;
36036 }
36037 return resultobj;
36038 fail:
36039 {
36040 if (temp3)
36041 delete arg3;
36042 }
36043 {
36044 if (temp4)
36045 delete arg4;
36046 }
36047 return NULL;
36048 }
36049
36050
36051 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36052 PyObject *resultobj;
36053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36054 wxMenu *result;
36055 PyObject * obj0 = 0 ;
36056 char *kwnames[] = {
36057 (char *) "self", NULL
36058 };
36059
36060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36062 if (SWIG_arg_fail(1)) SWIG_fail;
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36066
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 {
36071 resultobj = wxPyMake_wxObject(result, 0);
36072 }
36073 return resultobj;
36074 fail:
36075 return NULL;
36076 }
36077
36078
36079 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36080 PyObject *resultobj;
36081 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36082 wxMenu *arg2 = (wxMenu *) 0 ;
36083 PyObject * obj0 = 0 ;
36084 PyObject * obj1 = 0 ;
36085 char *kwnames[] = {
36086 (char *) "self",(char *) "menu", NULL
36087 };
36088
36089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36091 if (SWIG_arg_fail(1)) SWIG_fail;
36092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36093 if (SWIG_arg_fail(2)) SWIG_fail;
36094 {
36095 PyThreadState* __tstate = wxPyBeginAllowThreads();
36096 (arg1)->SetMenu(arg2);
36097
36098 wxPyEndAllowThreads(__tstate);
36099 if (PyErr_Occurred()) SWIG_fail;
36100 }
36101 Py_INCREF(Py_None); resultobj = Py_None;
36102 return resultobj;
36103 fail:
36104 return NULL;
36105 }
36106
36107
36108 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36109 PyObject *resultobj;
36110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36111 int arg2 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 char *kwnames[] = {
36115 (char *) "self",(char *) "id", NULL
36116 };
36117
36118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36120 if (SWIG_arg_fail(1)) SWIG_fail;
36121 {
36122 arg2 = (int)(SWIG_As_int(obj1));
36123 if (SWIG_arg_fail(2)) SWIG_fail;
36124 }
36125 {
36126 PyThreadState* __tstate = wxPyBeginAllowThreads();
36127 (arg1)->SetId(arg2);
36128
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 Py_INCREF(Py_None); resultobj = Py_None;
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36140 PyObject *resultobj;
36141 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36142 int result;
36143 PyObject * obj0 = 0 ;
36144 char *kwnames[] = {
36145 (char *) "self", NULL
36146 };
36147
36148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(1)) SWIG_fail;
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (int)((wxMenuItem const *)arg1)->GetId();
36154
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = SWIG_From_int((int)(result));
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36168 PyObject *resultobj;
36169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36170 bool result;
36171 PyObject * obj0 = 0 ;
36172 char *kwnames[] = {
36173 (char *) "self", NULL
36174 };
36175
36176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36178 if (SWIG_arg_fail(1)) SWIG_fail;
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36182
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 {
36187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36188 }
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36196 PyObject *resultobj;
36197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36198 wxString *arg2 = 0 ;
36199 bool temp2 = false ;
36200 PyObject * obj0 = 0 ;
36201 PyObject * obj1 = 0 ;
36202 char *kwnames[] = {
36203 (char *) "self",(char *) "str", NULL
36204 };
36205
36206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36208 if (SWIG_arg_fail(1)) SWIG_fail;
36209 {
36210 arg2 = wxString_in_helper(obj1);
36211 if (arg2 == NULL) SWIG_fail;
36212 temp2 = true;
36213 }
36214 {
36215 PyThreadState* __tstate = wxPyBeginAllowThreads();
36216 (arg1)->SetText((wxString const &)*arg2);
36217
36218 wxPyEndAllowThreads(__tstate);
36219 if (PyErr_Occurred()) SWIG_fail;
36220 }
36221 Py_INCREF(Py_None); resultobj = Py_None;
36222 {
36223 if (temp2)
36224 delete arg2;
36225 }
36226 return resultobj;
36227 fail:
36228 {
36229 if (temp2)
36230 delete arg2;
36231 }
36232 return NULL;
36233 }
36234
36235
36236 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36237 PyObject *resultobj;
36238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36239 wxString result;
36240 PyObject * obj0 = 0 ;
36241 char *kwnames[] = {
36242 (char *) "self", NULL
36243 };
36244
36245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36247 if (SWIG_arg_fail(1)) SWIG_fail;
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = ((wxMenuItem const *)arg1)->GetLabel();
36251
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 {
36256 #if wxUSE_UNICODE
36257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36258 #else
36259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36260 #endif
36261 }
36262 return resultobj;
36263 fail:
36264 return NULL;
36265 }
36266
36267
36268 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36269 PyObject *resultobj;
36270 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36271 wxString *result;
36272 PyObject * obj0 = 0 ;
36273 char *kwnames[] = {
36274 (char *) "self", NULL
36275 };
36276
36277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36279 if (SWIG_arg_fail(1)) SWIG_fail;
36280 {
36281 PyThreadState* __tstate = wxPyBeginAllowThreads();
36282 {
36283 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36284 result = (wxString *) &_result_ref;
36285 }
36286
36287 wxPyEndAllowThreads(__tstate);
36288 if (PyErr_Occurred()) SWIG_fail;
36289 }
36290 {
36291 #if wxUSE_UNICODE
36292 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36293 #else
36294 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36295 #endif
36296 }
36297 return resultobj;
36298 fail:
36299 return NULL;
36300 }
36301
36302
36303 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36304 PyObject *resultobj;
36305 wxString *arg1 = 0 ;
36306 wxString result;
36307 bool temp1 = false ;
36308 PyObject * obj0 = 0 ;
36309 char *kwnames[] = {
36310 (char *) "text", NULL
36311 };
36312
36313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36314 {
36315 arg1 = wxString_in_helper(obj0);
36316 if (arg1 == NULL) SWIG_fail;
36317 temp1 = true;
36318 }
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36322
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 {
36327 #if wxUSE_UNICODE
36328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36329 #else
36330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36331 #endif
36332 }
36333 {
36334 if (temp1)
36335 delete arg1;
36336 }
36337 return resultobj;
36338 fail:
36339 {
36340 if (temp1)
36341 delete arg1;
36342 }
36343 return NULL;
36344 }
36345
36346
36347 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36348 PyObject *resultobj;
36349 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36350 wxItemKind result;
36351 PyObject * obj0 = 0 ;
36352 char *kwnames[] = {
36353 (char *) "self", NULL
36354 };
36355
36356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36358 if (SWIG_arg_fail(1)) SWIG_fail;
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36362
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 resultobj = SWIG_From_int((result));
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36374 PyObject *resultobj;
36375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36376 wxItemKind arg2 ;
36377 PyObject * obj0 = 0 ;
36378 PyObject * obj1 = 0 ;
36379 char *kwnames[] = {
36380 (char *) "self",(char *) "kind", NULL
36381 };
36382
36383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36385 if (SWIG_arg_fail(1)) SWIG_fail;
36386 {
36387 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36388 if (SWIG_arg_fail(2)) SWIG_fail;
36389 }
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 (arg1)->SetKind((wxItemKind )arg2);
36393
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 Py_INCREF(Py_None); resultobj = Py_None;
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj;
36406 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36407 bool arg2 ;
36408 PyObject * obj0 = 0 ;
36409 PyObject * obj1 = 0 ;
36410 char *kwnames[] = {
36411 (char *) "self",(char *) "checkable", NULL
36412 };
36413
36414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36416 if (SWIG_arg_fail(1)) SWIG_fail;
36417 {
36418 arg2 = (bool)(SWIG_As_bool(obj1));
36419 if (SWIG_arg_fail(2)) SWIG_fail;
36420 }
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 (arg1)->SetCheckable(arg2);
36424
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 Py_INCREF(Py_None); resultobj = Py_None;
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj;
36437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36438 bool result;
36439 PyObject * obj0 = 0 ;
36440 char *kwnames[] = {
36441 (char *) "self", NULL
36442 };
36443
36444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36446 if (SWIG_arg_fail(1)) SWIG_fail;
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36450
36451 wxPyEndAllowThreads(__tstate);
36452 if (PyErr_Occurred()) SWIG_fail;
36453 }
36454 {
36455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36456 }
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36464 PyObject *resultobj;
36465 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36466 bool result;
36467 PyObject * obj0 = 0 ;
36468 char *kwnames[] = {
36469 (char *) "self", NULL
36470 };
36471
36472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36474 if (SWIG_arg_fail(1)) SWIG_fail;
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36478
36479 wxPyEndAllowThreads(__tstate);
36480 if (PyErr_Occurred()) SWIG_fail;
36481 }
36482 {
36483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36484 }
36485 return resultobj;
36486 fail:
36487 return NULL;
36488 }
36489
36490
36491 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36492 PyObject *resultobj;
36493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36494 wxMenu *arg2 = (wxMenu *) 0 ;
36495 PyObject * obj0 = 0 ;
36496 PyObject * obj1 = 0 ;
36497 char *kwnames[] = {
36498 (char *) "self",(char *) "menu", NULL
36499 };
36500
36501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36503 if (SWIG_arg_fail(1)) SWIG_fail;
36504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36505 if (SWIG_arg_fail(2)) SWIG_fail;
36506 {
36507 PyThreadState* __tstate = wxPyBeginAllowThreads();
36508 (arg1)->SetSubMenu(arg2);
36509
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 Py_INCREF(Py_None); resultobj = Py_None;
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj;
36522 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36523 wxMenu *result;
36524 PyObject * obj0 = 0 ;
36525 char *kwnames[] = {
36526 (char *) "self", NULL
36527 };
36528
36529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36531 if (SWIG_arg_fail(1)) SWIG_fail;
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36535
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 resultobj = wxPyMake_wxObject(result, 0);
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj;
36550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36551 bool arg2 = (bool) true ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char *kwnames[] = {
36555 (char *) "self",(char *) "enable", NULL
36556 };
36557
36558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36560 if (SWIG_arg_fail(1)) SWIG_fail;
36561 if (obj1) {
36562 {
36563 arg2 = (bool)(SWIG_As_bool(obj1));
36564 if (SWIG_arg_fail(2)) SWIG_fail;
36565 }
36566 }
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 (arg1)->Enable(arg2);
36570
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 Py_INCREF(Py_None); resultobj = Py_None;
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36582 PyObject *resultobj;
36583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36584 bool result;
36585 PyObject * obj0 = 0 ;
36586 char *kwnames[] = {
36587 (char *) "self", NULL
36588 };
36589
36590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36592 if (SWIG_arg_fail(1)) SWIG_fail;
36593 {
36594 PyThreadState* __tstate = wxPyBeginAllowThreads();
36595 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36596
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 {
36601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36602 }
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj;
36611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36612 bool arg2 = (bool) true ;
36613 PyObject * obj0 = 0 ;
36614 PyObject * obj1 = 0 ;
36615 char *kwnames[] = {
36616 (char *) "self",(char *) "check", NULL
36617 };
36618
36619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36621 if (SWIG_arg_fail(1)) SWIG_fail;
36622 if (obj1) {
36623 {
36624 arg2 = (bool)(SWIG_As_bool(obj1));
36625 if (SWIG_arg_fail(2)) SWIG_fail;
36626 }
36627 }
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 (arg1)->Check(arg2);
36631
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 Py_INCREF(Py_None); resultobj = Py_None;
36636 return resultobj;
36637 fail:
36638 return NULL;
36639 }
36640
36641
36642 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36643 PyObject *resultobj;
36644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36645 bool result;
36646 PyObject * obj0 = 0 ;
36647 char *kwnames[] = {
36648 (char *) "self", NULL
36649 };
36650
36651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36653 if (SWIG_arg_fail(1)) SWIG_fail;
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36657
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 {
36662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36663 }
36664 return resultobj;
36665 fail:
36666 return NULL;
36667 }
36668
36669
36670 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36671 PyObject *resultobj;
36672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36673 PyObject * obj0 = 0 ;
36674 char *kwnames[] = {
36675 (char *) "self", NULL
36676 };
36677
36678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36680 if (SWIG_arg_fail(1)) SWIG_fail;
36681 {
36682 PyThreadState* __tstate = wxPyBeginAllowThreads();
36683 (arg1)->Toggle();
36684
36685 wxPyEndAllowThreads(__tstate);
36686 if (PyErr_Occurred()) SWIG_fail;
36687 }
36688 Py_INCREF(Py_None); resultobj = Py_None;
36689 return resultobj;
36690 fail:
36691 return NULL;
36692 }
36693
36694
36695 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36696 PyObject *resultobj;
36697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36698 wxString *arg2 = 0 ;
36699 bool temp2 = false ;
36700 PyObject * obj0 = 0 ;
36701 PyObject * obj1 = 0 ;
36702 char *kwnames[] = {
36703 (char *) "self",(char *) "str", NULL
36704 };
36705
36706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36708 if (SWIG_arg_fail(1)) SWIG_fail;
36709 {
36710 arg2 = wxString_in_helper(obj1);
36711 if (arg2 == NULL) SWIG_fail;
36712 temp2 = true;
36713 }
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 (arg1)->SetHelp((wxString const &)*arg2);
36717
36718 wxPyEndAllowThreads(__tstate);
36719 if (PyErr_Occurred()) SWIG_fail;
36720 }
36721 Py_INCREF(Py_None); resultobj = Py_None;
36722 {
36723 if (temp2)
36724 delete arg2;
36725 }
36726 return resultobj;
36727 fail:
36728 {
36729 if (temp2)
36730 delete arg2;
36731 }
36732 return NULL;
36733 }
36734
36735
36736 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36737 PyObject *resultobj;
36738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36739 wxString *result;
36740 PyObject * obj0 = 0 ;
36741 char *kwnames[] = {
36742 (char *) "self", NULL
36743 };
36744
36745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36747 if (SWIG_arg_fail(1)) SWIG_fail;
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 {
36751 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36752 result = (wxString *) &_result_ref;
36753 }
36754
36755 wxPyEndAllowThreads(__tstate);
36756 if (PyErr_Occurred()) SWIG_fail;
36757 }
36758 {
36759 #if wxUSE_UNICODE
36760 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36761 #else
36762 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36763 #endif
36764 }
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36772 PyObject *resultobj;
36773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36774 wxAcceleratorEntry *result;
36775 PyObject * obj0 = 0 ;
36776 char *kwnames[] = {
36777 (char *) "self", NULL
36778 };
36779
36780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36782 if (SWIG_arg_fail(1)) SWIG_fail;
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36786
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36791 return resultobj;
36792 fail:
36793 return NULL;
36794 }
36795
36796
36797 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36798 PyObject *resultobj;
36799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36800 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36801 PyObject * obj0 = 0 ;
36802 PyObject * obj1 = 0 ;
36803 char *kwnames[] = {
36804 (char *) "self",(char *) "accel", NULL
36805 };
36806
36807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36809 if (SWIG_arg_fail(1)) SWIG_fail;
36810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36811 if (SWIG_arg_fail(2)) SWIG_fail;
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 (arg1)->SetAccel(arg2);
36815
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 Py_INCREF(Py_None); resultobj = Py_None;
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36827 PyObject *resultobj;
36828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36829 wxFont *arg2 = 0 ;
36830 PyObject * obj0 = 0 ;
36831 PyObject * obj1 = 0 ;
36832 char *kwnames[] = {
36833 (char *) "self",(char *) "font", NULL
36834 };
36835
36836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36838 if (SWIG_arg_fail(1)) SWIG_fail;
36839 {
36840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36841 if (SWIG_arg_fail(2)) SWIG_fail;
36842 if (arg2 == NULL) {
36843 SWIG_null_ref("wxFont");
36844 }
36845 if (SWIG_arg_fail(2)) SWIG_fail;
36846 }
36847 {
36848 PyThreadState* __tstate = wxPyBeginAllowThreads();
36849 (arg1)->SetFont((wxFont const &)*arg2);
36850
36851 wxPyEndAllowThreads(__tstate);
36852 if (PyErr_Occurred()) SWIG_fail;
36853 }
36854 Py_INCREF(Py_None); resultobj = Py_None;
36855 return resultobj;
36856 fail:
36857 return NULL;
36858 }
36859
36860
36861 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36862 PyObject *resultobj;
36863 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36864 wxFont result;
36865 PyObject * obj0 = 0 ;
36866 char *kwnames[] = {
36867 (char *) "self", NULL
36868 };
36869
36870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36872 if (SWIG_arg_fail(1)) SWIG_fail;
36873 {
36874 PyThreadState* __tstate = wxPyBeginAllowThreads();
36875 result = (arg1)->GetFont();
36876
36877 wxPyEndAllowThreads(__tstate);
36878 if (PyErr_Occurred()) SWIG_fail;
36879 }
36880 {
36881 wxFont * resultptr;
36882 resultptr = new wxFont((wxFont &)(result));
36883 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36884 }
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj;
36893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36894 wxColour *arg2 = 0 ;
36895 wxColour temp2 ;
36896 PyObject * obj0 = 0 ;
36897 PyObject * obj1 = 0 ;
36898 char *kwnames[] = {
36899 (char *) "self",(char *) "colText", NULL
36900 };
36901
36902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36904 if (SWIG_arg_fail(1)) SWIG_fail;
36905 {
36906 arg2 = &temp2;
36907 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36908 }
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 (arg1)->SetTextColour((wxColour const &)*arg2);
36912
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 Py_INCREF(Py_None); resultobj = Py_None;
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj;
36925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36926 wxColour result;
36927 PyObject * obj0 = 0 ;
36928 char *kwnames[] = {
36929 (char *) "self", NULL
36930 };
36931
36932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36934 if (SWIG_arg_fail(1)) SWIG_fail;
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 result = (arg1)->GetTextColour();
36938
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 {
36943 wxColour * resultptr;
36944 resultptr = new wxColour((wxColour &)(result));
36945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36954 PyObject *resultobj;
36955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36956 wxColour *arg2 = 0 ;
36957 wxColour temp2 ;
36958 PyObject * obj0 = 0 ;
36959 PyObject * obj1 = 0 ;
36960 char *kwnames[] = {
36961 (char *) "self",(char *) "colBack", NULL
36962 };
36963
36964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36966 if (SWIG_arg_fail(1)) SWIG_fail;
36967 {
36968 arg2 = &temp2;
36969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36970 }
36971 {
36972 PyThreadState* __tstate = wxPyBeginAllowThreads();
36973 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36974
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 Py_INCREF(Py_None); resultobj = Py_None;
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj;
36987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36988 wxColour result;
36989 PyObject * obj0 = 0 ;
36990 char *kwnames[] = {
36991 (char *) "self", NULL
36992 };
36993
36994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36996 if (SWIG_arg_fail(1)) SWIG_fail;
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 result = (arg1)->GetBackgroundColour();
37000
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 wxColour * resultptr;
37006 resultptr = new wxColour((wxColour &)(result));
37007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37008 }
37009 return resultobj;
37010 fail:
37011 return NULL;
37012 }
37013
37014
37015 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37016 PyObject *resultobj;
37017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37018 wxBitmap *arg2 = 0 ;
37019 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37020 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37021 PyObject * obj0 = 0 ;
37022 PyObject * obj1 = 0 ;
37023 PyObject * obj2 = 0 ;
37024 char *kwnames[] = {
37025 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37026 };
37027
37028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37030 if (SWIG_arg_fail(1)) SWIG_fail;
37031 {
37032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37033 if (SWIG_arg_fail(2)) SWIG_fail;
37034 if (arg2 == NULL) {
37035 SWIG_null_ref("wxBitmap");
37036 }
37037 if (SWIG_arg_fail(2)) SWIG_fail;
37038 }
37039 if (obj2) {
37040 {
37041 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37042 if (SWIG_arg_fail(3)) SWIG_fail;
37043 if (arg3 == NULL) {
37044 SWIG_null_ref("wxBitmap");
37045 }
37046 if (SWIG_arg_fail(3)) SWIG_fail;
37047 }
37048 }
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37052
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 Py_INCREF(Py_None); resultobj = Py_None;
37057 return resultobj;
37058 fail:
37059 return NULL;
37060 }
37061
37062
37063 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37064 PyObject *resultobj;
37065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37066 wxBitmap *arg2 = 0 ;
37067 PyObject * obj0 = 0 ;
37068 PyObject * obj1 = 0 ;
37069 char *kwnames[] = {
37070 (char *) "self",(char *) "bmpDisabled", NULL
37071 };
37072
37073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37075 if (SWIG_arg_fail(1)) SWIG_fail;
37076 {
37077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37078 if (SWIG_arg_fail(2)) SWIG_fail;
37079 if (arg2 == NULL) {
37080 SWIG_null_ref("wxBitmap");
37081 }
37082 if (SWIG_arg_fail(2)) SWIG_fail;
37083 }
37084 {
37085 PyThreadState* __tstate = wxPyBeginAllowThreads();
37086 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37087
37088 wxPyEndAllowThreads(__tstate);
37089 if (PyErr_Occurred()) SWIG_fail;
37090 }
37091 Py_INCREF(Py_None); resultobj = Py_None;
37092 return resultobj;
37093 fail:
37094 return NULL;
37095 }
37096
37097
37098 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37099 PyObject *resultobj;
37100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37101 wxBitmap *result;
37102 PyObject * obj0 = 0 ;
37103 char *kwnames[] = {
37104 (char *) "self", NULL
37105 };
37106
37107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37109 if (SWIG_arg_fail(1)) SWIG_fail;
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 {
37113 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37114 result = (wxBitmap *) &_result_ref;
37115 }
37116
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 {
37121 wxBitmap* resultptr = new wxBitmap(*result);
37122 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37123 }
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj;
37132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37133 int arg2 ;
37134 PyObject * obj0 = 0 ;
37135 PyObject * obj1 = 0 ;
37136 char *kwnames[] = {
37137 (char *) "self",(char *) "nWidth", NULL
37138 };
37139
37140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37142 if (SWIG_arg_fail(1)) SWIG_fail;
37143 {
37144 arg2 = (int)(SWIG_As_int(obj1));
37145 if (SWIG_arg_fail(2)) SWIG_fail;
37146 }
37147 {
37148 PyThreadState* __tstate = wxPyBeginAllowThreads();
37149 (arg1)->SetMarginWidth(arg2);
37150
37151 wxPyEndAllowThreads(__tstate);
37152 if (PyErr_Occurred()) SWIG_fail;
37153 }
37154 Py_INCREF(Py_None); resultobj = Py_None;
37155 return resultobj;
37156 fail:
37157 return NULL;
37158 }
37159
37160
37161 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37162 PyObject *resultobj;
37163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37164 int result;
37165 PyObject * obj0 = 0 ;
37166 char *kwnames[] = {
37167 (char *) "self", NULL
37168 };
37169
37170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37172 if (SWIG_arg_fail(1)) SWIG_fail;
37173 {
37174 PyThreadState* __tstate = wxPyBeginAllowThreads();
37175 result = (int)(arg1)->GetMarginWidth();
37176
37177 wxPyEndAllowThreads(__tstate);
37178 if (PyErr_Occurred()) SWIG_fail;
37179 }
37180 {
37181 resultobj = SWIG_From_int((int)(result));
37182 }
37183 return resultobj;
37184 fail:
37185 return NULL;
37186 }
37187
37188
37189 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37190 PyObject *resultobj;
37191 int result;
37192 char *kwnames[] = {
37193 NULL
37194 };
37195
37196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 result = (int)wxMenuItem::GetDefaultMarginWidth();
37200
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 {
37205 resultobj = SWIG_From_int((int)(result));
37206 }
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj;
37215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37216 bool result;
37217 PyObject * obj0 = 0 ;
37218 char *kwnames[] = {
37219 (char *) "self", NULL
37220 };
37221
37222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37224 if (SWIG_arg_fail(1)) SWIG_fail;
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 result = (bool)(arg1)->IsOwnerDrawn();
37228
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 {
37233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37234 }
37235 return resultobj;
37236 fail:
37237 return NULL;
37238 }
37239
37240
37241 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37242 PyObject *resultobj;
37243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37244 bool arg2 = (bool) true ;
37245 PyObject * obj0 = 0 ;
37246 PyObject * obj1 = 0 ;
37247 char *kwnames[] = {
37248 (char *) "self",(char *) "ownerDrawn", NULL
37249 };
37250
37251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37253 if (SWIG_arg_fail(1)) SWIG_fail;
37254 if (obj1) {
37255 {
37256 arg2 = (bool)(SWIG_As_bool(obj1));
37257 if (SWIG_arg_fail(2)) SWIG_fail;
37258 }
37259 }
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 (arg1)->SetOwnerDrawn(arg2);
37263
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 Py_INCREF(Py_None); resultobj = Py_None;
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj;
37276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37277 PyObject * obj0 = 0 ;
37278 char *kwnames[] = {
37279 (char *) "self", NULL
37280 };
37281
37282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37284 if (SWIG_arg_fail(1)) SWIG_fail;
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 (arg1)->ResetOwnerDrawn();
37288
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 Py_INCREF(Py_None); resultobj = Py_None;
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj;
37301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37302 wxBitmap *arg2 = 0 ;
37303 PyObject * obj0 = 0 ;
37304 PyObject * obj1 = 0 ;
37305 char *kwnames[] = {
37306 (char *) "self",(char *) "bitmap", NULL
37307 };
37308
37309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37311 if (SWIG_arg_fail(1)) SWIG_fail;
37312 {
37313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37314 if (SWIG_arg_fail(2)) SWIG_fail;
37315 if (arg2 == NULL) {
37316 SWIG_null_ref("wxBitmap");
37317 }
37318 if (SWIG_arg_fail(2)) SWIG_fail;
37319 }
37320 {
37321 PyThreadState* __tstate = wxPyBeginAllowThreads();
37322 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37323
37324 wxPyEndAllowThreads(__tstate);
37325 if (PyErr_Occurred()) SWIG_fail;
37326 }
37327 Py_INCREF(Py_None); resultobj = Py_None;
37328 return resultobj;
37329 fail:
37330 return NULL;
37331 }
37332
37333
37334 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37335 PyObject *resultobj;
37336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37337 wxBitmap *result;
37338 PyObject * obj0 = 0 ;
37339 char *kwnames[] = {
37340 (char *) "self", NULL
37341 };
37342
37343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37345 if (SWIG_arg_fail(1)) SWIG_fail;
37346 {
37347 PyThreadState* __tstate = wxPyBeginAllowThreads();
37348 {
37349 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37350 result = (wxBitmap *) &_result_ref;
37351 }
37352
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 {
37357 wxBitmap* resultptr = new wxBitmap(*result);
37358 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37359 }
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37367 PyObject *obj;
37368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37369 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37370 Py_INCREF(obj);
37371 return Py_BuildValue((char *)"");
37372 }
37373 static int _wrap_ControlNameStr_set(PyObject *) {
37374 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37375 return 1;
37376 }
37377
37378
37379 static PyObject *_wrap_ControlNameStr_get(void) {
37380 PyObject *pyobj;
37381
37382 {
37383 #if wxUSE_UNICODE
37384 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37385 #else
37386 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37387 #endif
37388 }
37389 return pyobj;
37390 }
37391
37392
37393 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 int arg2 = (int) -1 ;
37397 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37398 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37399 wxSize const &arg4_defvalue = wxDefaultSize ;
37400 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37401 long arg5 = (long) 0 ;
37402 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37403 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37404 wxString const &arg7_defvalue = wxPyControlNameStr ;
37405 wxString *arg7 = (wxString *) &arg7_defvalue ;
37406 wxControl *result;
37407 wxPoint temp3 ;
37408 wxSize temp4 ;
37409 bool temp7 = false ;
37410 PyObject * obj0 = 0 ;
37411 PyObject * obj1 = 0 ;
37412 PyObject * obj2 = 0 ;
37413 PyObject * obj3 = 0 ;
37414 PyObject * obj4 = 0 ;
37415 PyObject * obj5 = 0 ;
37416 PyObject * obj6 = 0 ;
37417 char *kwnames[] = {
37418 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37419 };
37420
37421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37423 if (SWIG_arg_fail(1)) SWIG_fail;
37424 if (obj1) {
37425 {
37426 arg2 = (int)(SWIG_As_int(obj1));
37427 if (SWIG_arg_fail(2)) SWIG_fail;
37428 }
37429 }
37430 if (obj2) {
37431 {
37432 arg3 = &temp3;
37433 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37434 }
37435 }
37436 if (obj3) {
37437 {
37438 arg4 = &temp4;
37439 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37440 }
37441 }
37442 if (obj4) {
37443 {
37444 arg5 = (long)(SWIG_As_long(obj4));
37445 if (SWIG_arg_fail(5)) SWIG_fail;
37446 }
37447 }
37448 if (obj5) {
37449 {
37450 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37451 if (SWIG_arg_fail(6)) SWIG_fail;
37452 if (arg6 == NULL) {
37453 SWIG_null_ref("wxValidator");
37454 }
37455 if (SWIG_arg_fail(6)) SWIG_fail;
37456 }
37457 }
37458 if (obj6) {
37459 {
37460 arg7 = wxString_in_helper(obj6);
37461 if (arg7 == NULL) SWIG_fail;
37462 temp7 = true;
37463 }
37464 }
37465 {
37466 if (!wxPyCheckForApp()) SWIG_fail;
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37469
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37474 {
37475 if (temp7)
37476 delete arg7;
37477 }
37478 return resultobj;
37479 fail:
37480 {
37481 if (temp7)
37482 delete arg7;
37483 }
37484 return NULL;
37485 }
37486
37487
37488 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37489 PyObject *resultobj;
37490 wxControl *result;
37491 char *kwnames[] = {
37492 NULL
37493 };
37494
37495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37496 {
37497 if (!wxPyCheckForApp()) SWIG_fail;
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 result = (wxControl *)new wxControl();
37500
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj;
37513 wxControl *arg1 = (wxControl *) 0 ;
37514 wxWindow *arg2 = (wxWindow *) 0 ;
37515 int arg3 = (int) -1 ;
37516 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37517 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37518 wxSize const &arg5_defvalue = wxDefaultSize ;
37519 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37520 long arg6 = (long) 0 ;
37521 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37522 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37523 wxString const &arg8_defvalue = wxPyControlNameStr ;
37524 wxString *arg8 = (wxString *) &arg8_defvalue ;
37525 bool result;
37526 wxPoint temp4 ;
37527 wxSize temp5 ;
37528 bool temp8 = false ;
37529 PyObject * obj0 = 0 ;
37530 PyObject * obj1 = 0 ;
37531 PyObject * obj2 = 0 ;
37532 PyObject * obj3 = 0 ;
37533 PyObject * obj4 = 0 ;
37534 PyObject * obj5 = 0 ;
37535 PyObject * obj6 = 0 ;
37536 PyObject * obj7 = 0 ;
37537 char *kwnames[] = {
37538 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37539 };
37540
37541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37543 if (SWIG_arg_fail(1)) SWIG_fail;
37544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37545 if (SWIG_arg_fail(2)) SWIG_fail;
37546 if (obj2) {
37547 {
37548 arg3 = (int)(SWIG_As_int(obj2));
37549 if (SWIG_arg_fail(3)) SWIG_fail;
37550 }
37551 }
37552 if (obj3) {
37553 {
37554 arg4 = &temp4;
37555 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37556 }
37557 }
37558 if (obj4) {
37559 {
37560 arg5 = &temp5;
37561 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37562 }
37563 }
37564 if (obj5) {
37565 {
37566 arg6 = (long)(SWIG_As_long(obj5));
37567 if (SWIG_arg_fail(6)) SWIG_fail;
37568 }
37569 }
37570 if (obj6) {
37571 {
37572 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37573 if (SWIG_arg_fail(7)) SWIG_fail;
37574 if (arg7 == NULL) {
37575 SWIG_null_ref("wxValidator");
37576 }
37577 if (SWIG_arg_fail(7)) SWIG_fail;
37578 }
37579 }
37580 if (obj7) {
37581 {
37582 arg8 = wxString_in_helper(obj7);
37583 if (arg8 == NULL) SWIG_fail;
37584 temp8 = true;
37585 }
37586 }
37587 {
37588 PyThreadState* __tstate = wxPyBeginAllowThreads();
37589 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37590
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 {
37595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37596 }
37597 {
37598 if (temp8)
37599 delete arg8;
37600 }
37601 return resultobj;
37602 fail:
37603 {
37604 if (temp8)
37605 delete arg8;
37606 }
37607 return NULL;
37608 }
37609
37610
37611 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37612 PyObject *resultobj;
37613 wxControl *arg1 = (wxControl *) 0 ;
37614 wxCommandEvent *arg2 = 0 ;
37615 PyObject * obj0 = 0 ;
37616 PyObject * obj1 = 0 ;
37617 char *kwnames[] = {
37618 (char *) "self",(char *) "event", NULL
37619 };
37620
37621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37626 if (SWIG_arg_fail(2)) SWIG_fail;
37627 if (arg2 == NULL) {
37628 SWIG_null_ref("wxCommandEvent");
37629 }
37630 if (SWIG_arg_fail(2)) SWIG_fail;
37631 }
37632 {
37633 PyThreadState* __tstate = wxPyBeginAllowThreads();
37634 (arg1)->Command(*arg2);
37635
37636 wxPyEndAllowThreads(__tstate);
37637 if (PyErr_Occurred()) SWIG_fail;
37638 }
37639 Py_INCREF(Py_None); resultobj = Py_None;
37640 return resultobj;
37641 fail:
37642 return NULL;
37643 }
37644
37645
37646 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37647 PyObject *resultobj;
37648 wxControl *arg1 = (wxControl *) 0 ;
37649 wxString result;
37650 PyObject * obj0 = 0 ;
37651 char *kwnames[] = {
37652 (char *) "self", NULL
37653 };
37654
37655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37657 if (SWIG_arg_fail(1)) SWIG_fail;
37658 {
37659 PyThreadState* __tstate = wxPyBeginAllowThreads();
37660 result = (arg1)->GetLabel();
37661
37662 wxPyEndAllowThreads(__tstate);
37663 if (PyErr_Occurred()) SWIG_fail;
37664 }
37665 {
37666 #if wxUSE_UNICODE
37667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37668 #else
37669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37670 #endif
37671 }
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj;
37680 wxControl *arg1 = (wxControl *) 0 ;
37681 wxString *arg2 = 0 ;
37682 bool temp2 = false ;
37683 PyObject * obj0 = 0 ;
37684 PyObject * obj1 = 0 ;
37685 char *kwnames[] = {
37686 (char *) "self",(char *) "label", NULL
37687 };
37688
37689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37691 if (SWIG_arg_fail(1)) SWIG_fail;
37692 {
37693 arg2 = wxString_in_helper(obj1);
37694 if (arg2 == NULL) SWIG_fail;
37695 temp2 = true;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 (arg1)->SetLabel((wxString const &)*arg2);
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 Py_INCREF(Py_None); resultobj = Py_None;
37705 {
37706 if (temp2)
37707 delete arg2;
37708 }
37709 return resultobj;
37710 fail:
37711 {
37712 if (temp2)
37713 delete arg2;
37714 }
37715 return NULL;
37716 }
37717
37718
37719 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37720 PyObject *resultobj;
37721 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37722 wxVisualAttributes result;
37723 PyObject * obj0 = 0 ;
37724 char *kwnames[] = {
37725 (char *) "variant", NULL
37726 };
37727
37728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37729 if (obj0) {
37730 {
37731 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37732 if (SWIG_arg_fail(1)) SWIG_fail;
37733 }
37734 }
37735 {
37736 if (!wxPyCheckForApp()) SWIG_fail;
37737 PyThreadState* __tstate = wxPyBeginAllowThreads();
37738 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37739
37740 wxPyEndAllowThreads(__tstate);
37741 if (PyErr_Occurred()) SWIG_fail;
37742 }
37743 {
37744 wxVisualAttributes * resultptr;
37745 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37746 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37747 }
37748 return resultobj;
37749 fail:
37750 return NULL;
37751 }
37752
37753
37754 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37755 PyObject *obj;
37756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37757 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37758 Py_INCREF(obj);
37759 return Py_BuildValue((char *)"");
37760 }
37761 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37762 PyObject *resultobj;
37763 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37764 wxString *arg2 = 0 ;
37765 PyObject *arg3 = (PyObject *) NULL ;
37766 int result;
37767 bool temp2 = false ;
37768 PyObject * obj0 = 0 ;
37769 PyObject * obj1 = 0 ;
37770 PyObject * obj2 = 0 ;
37771 char *kwnames[] = {
37772 (char *) "self",(char *) "item",(char *) "clientData", NULL
37773 };
37774
37775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37777 if (SWIG_arg_fail(1)) SWIG_fail;
37778 {
37779 arg2 = wxString_in_helper(obj1);
37780 if (arg2 == NULL) SWIG_fail;
37781 temp2 = true;
37782 }
37783 if (obj2) {
37784 arg3 = obj2;
37785 }
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 {
37794 resultobj = SWIG_From_int((int)(result));
37795 }
37796 {
37797 if (temp2)
37798 delete arg2;
37799 }
37800 return resultobj;
37801 fail:
37802 {
37803 if (temp2)
37804 delete arg2;
37805 }
37806 return NULL;
37807 }
37808
37809
37810 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37811 PyObject *resultobj;
37812 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37813 wxArrayString *arg2 = 0 ;
37814 bool temp2 = false ;
37815 PyObject * obj0 = 0 ;
37816 PyObject * obj1 = 0 ;
37817 char *kwnames[] = {
37818 (char *) "self",(char *) "strings", NULL
37819 };
37820
37821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37823 if (SWIG_arg_fail(1)) SWIG_fail;
37824 {
37825 if (! PySequence_Check(obj1)) {
37826 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37827 SWIG_fail;
37828 }
37829 arg2 = new wxArrayString;
37830 temp2 = true;
37831 int i, len=PySequence_Length(obj1);
37832 for (i=0; i<len; i++) {
37833 PyObject* item = PySequence_GetItem(obj1, i);
37834 wxString* s = wxString_in_helper(item);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 arg2->Add(*s);
37837 delete s;
37838 Py_DECREF(item);
37839 }
37840 }
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 (arg1)->Append((wxArrayString const &)*arg2);
37844
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 Py_INCREF(Py_None); resultobj = Py_None;
37849 {
37850 if (temp2) delete arg2;
37851 }
37852 return resultobj;
37853 fail:
37854 {
37855 if (temp2) delete arg2;
37856 }
37857 return NULL;
37858 }
37859
37860
37861 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37862 PyObject *resultobj;
37863 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37864 wxString *arg2 = 0 ;
37865 int arg3 ;
37866 PyObject *arg4 = (PyObject *) NULL ;
37867 int result;
37868 bool temp2 = false ;
37869 PyObject * obj0 = 0 ;
37870 PyObject * obj1 = 0 ;
37871 PyObject * obj2 = 0 ;
37872 PyObject * obj3 = 0 ;
37873 char *kwnames[] = {
37874 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37875 };
37876
37877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37879 if (SWIG_arg_fail(1)) SWIG_fail;
37880 {
37881 arg2 = wxString_in_helper(obj1);
37882 if (arg2 == NULL) SWIG_fail;
37883 temp2 = true;
37884 }
37885 {
37886 arg3 = (int)(SWIG_As_int(obj2));
37887 if (SWIG_arg_fail(3)) SWIG_fail;
37888 }
37889 if (obj3) {
37890 arg4 = obj3;
37891 }
37892 {
37893 PyThreadState* __tstate = wxPyBeginAllowThreads();
37894 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37895
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 {
37900 resultobj = SWIG_From_int((int)(result));
37901 }
37902 {
37903 if (temp2)
37904 delete arg2;
37905 }
37906 return resultobj;
37907 fail:
37908 {
37909 if (temp2)
37910 delete arg2;
37911 }
37912 return NULL;
37913 }
37914
37915
37916 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37917 PyObject *resultobj;
37918 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37919 PyObject * obj0 = 0 ;
37920 char *kwnames[] = {
37921 (char *) "self", NULL
37922 };
37923
37924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37926 if (SWIG_arg_fail(1)) SWIG_fail;
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 (arg1)->Clear();
37930
37931 wxPyEndAllowThreads(__tstate);
37932 if (PyErr_Occurred()) SWIG_fail;
37933 }
37934 Py_INCREF(Py_None); resultobj = Py_None;
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj;
37943 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37944 int arg2 ;
37945 PyObject * obj0 = 0 ;
37946 PyObject * obj1 = 0 ;
37947 char *kwnames[] = {
37948 (char *) "self",(char *) "n", NULL
37949 };
37950
37951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37953 if (SWIG_arg_fail(1)) SWIG_fail;
37954 {
37955 arg2 = (int)(SWIG_As_int(obj1));
37956 if (SWIG_arg_fail(2)) SWIG_fail;
37957 }
37958 {
37959 PyThreadState* __tstate = wxPyBeginAllowThreads();
37960 (arg1)->Delete(arg2);
37961
37962 wxPyEndAllowThreads(__tstate);
37963 if (PyErr_Occurred()) SWIG_fail;
37964 }
37965 Py_INCREF(Py_None); resultobj = Py_None;
37966 return resultobj;
37967 fail:
37968 return NULL;
37969 }
37970
37971
37972 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37973 PyObject *resultobj;
37974 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37975 int arg2 ;
37976 PyObject *result;
37977 PyObject * obj0 = 0 ;
37978 PyObject * obj1 = 0 ;
37979 char *kwnames[] = {
37980 (char *) "self",(char *) "n", NULL
37981 };
37982
37983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
37988 if (SWIG_arg_fail(2)) SWIG_fail;
37989 }
37990 {
37991 PyThreadState* __tstate = wxPyBeginAllowThreads();
37992 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37993
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 resultobj = result;
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38005 PyObject *resultobj;
38006 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38007 int arg2 ;
38008 PyObject *arg3 = (PyObject *) 0 ;
38009 PyObject * obj0 = 0 ;
38010 PyObject * obj1 = 0 ;
38011 PyObject * obj2 = 0 ;
38012 char *kwnames[] = {
38013 (char *) "self",(char *) "n",(char *) "clientData", NULL
38014 };
38015
38016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38018 if (SWIG_arg_fail(1)) SWIG_fail;
38019 {
38020 arg2 = (int)(SWIG_As_int(obj1));
38021 if (SWIG_arg_fail(2)) SWIG_fail;
38022 }
38023 arg3 = obj2;
38024 {
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 wxItemContainer_SetClientData(arg1,arg2,arg3);
38027
38028 wxPyEndAllowThreads(__tstate);
38029 if (PyErr_Occurred()) SWIG_fail;
38030 }
38031 Py_INCREF(Py_None); resultobj = Py_None;
38032 return resultobj;
38033 fail:
38034 return NULL;
38035 }
38036
38037
38038 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38039 PyObject *resultobj;
38040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38041 int result;
38042 PyObject * obj0 = 0 ;
38043 char *kwnames[] = {
38044 (char *) "self", NULL
38045 };
38046
38047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38049 if (SWIG_arg_fail(1)) SWIG_fail;
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (int)((wxItemContainer const *)arg1)->GetCount();
38053
38054 wxPyEndAllowThreads(__tstate);
38055 if (PyErr_Occurred()) SWIG_fail;
38056 }
38057 {
38058 resultobj = SWIG_From_int((int)(result));
38059 }
38060 return resultobj;
38061 fail:
38062 return NULL;
38063 }
38064
38065
38066 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38067 PyObject *resultobj;
38068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38069 bool result;
38070 PyObject * obj0 = 0 ;
38071 char *kwnames[] = {
38072 (char *) "self", NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38077 if (SWIG_arg_fail(1)) SWIG_fail;
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38081
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38087 }
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj;
38096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38097 int arg2 ;
38098 wxString result;
38099 PyObject * obj0 = 0 ;
38100 PyObject * obj1 = 0 ;
38101 char *kwnames[] = {
38102 (char *) "self",(char *) "n", NULL
38103 };
38104
38105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38107 if (SWIG_arg_fail(1)) SWIG_fail;
38108 {
38109 arg2 = (int)(SWIG_As_int(obj1));
38110 if (SWIG_arg_fail(2)) SWIG_fail;
38111 }
38112 {
38113 PyThreadState* __tstate = wxPyBeginAllowThreads();
38114 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38115
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 {
38120 #if wxUSE_UNICODE
38121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38122 #else
38123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38124 #endif
38125 }
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38133 PyObject *resultobj;
38134 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38135 wxArrayString result;
38136 PyObject * obj0 = 0 ;
38137 char *kwnames[] = {
38138 (char *) "self", NULL
38139 };
38140
38141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38143 if (SWIG_arg_fail(1)) SWIG_fail;
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = ((wxItemContainer const *)arg1)->GetStrings();
38147
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 {
38152 resultobj = wxArrayString2PyList_helper(result);
38153 }
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj;
38162 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38163 int arg2 ;
38164 wxString *arg3 = 0 ;
38165 bool temp3 = false ;
38166 PyObject * obj0 = 0 ;
38167 PyObject * obj1 = 0 ;
38168 PyObject * obj2 = 0 ;
38169 char *kwnames[] = {
38170 (char *) "self",(char *) "n",(char *) "s", NULL
38171 };
38172
38173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38175 if (SWIG_arg_fail(1)) SWIG_fail;
38176 {
38177 arg2 = (int)(SWIG_As_int(obj1));
38178 if (SWIG_arg_fail(2)) SWIG_fail;
38179 }
38180 {
38181 arg3 = wxString_in_helper(obj2);
38182 if (arg3 == NULL) SWIG_fail;
38183 temp3 = true;
38184 }
38185 {
38186 PyThreadState* __tstate = wxPyBeginAllowThreads();
38187 (arg1)->SetString(arg2,(wxString const &)*arg3);
38188
38189 wxPyEndAllowThreads(__tstate);
38190 if (PyErr_Occurred()) SWIG_fail;
38191 }
38192 Py_INCREF(Py_None); resultobj = Py_None;
38193 {
38194 if (temp3)
38195 delete arg3;
38196 }
38197 return resultobj;
38198 fail:
38199 {
38200 if (temp3)
38201 delete arg3;
38202 }
38203 return NULL;
38204 }
38205
38206
38207 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj;
38209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38210 wxString *arg2 = 0 ;
38211 int result;
38212 bool temp2 = false ;
38213 PyObject * obj0 = 0 ;
38214 PyObject * obj1 = 0 ;
38215 char *kwnames[] = {
38216 (char *) "self",(char *) "s", NULL
38217 };
38218
38219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38221 if (SWIG_arg_fail(1)) SWIG_fail;
38222 {
38223 arg2 = wxString_in_helper(obj1);
38224 if (arg2 == NULL) SWIG_fail;
38225 temp2 = true;
38226 }
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 resultobj = SWIG_From_int((int)(result));
38236 }
38237 {
38238 if (temp2)
38239 delete arg2;
38240 }
38241 return resultobj;
38242 fail:
38243 {
38244 if (temp2)
38245 delete arg2;
38246 }
38247 return NULL;
38248 }
38249
38250
38251 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38252 PyObject *resultobj;
38253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38254 int arg2 ;
38255 PyObject * obj0 = 0 ;
38256 PyObject * obj1 = 0 ;
38257 char *kwnames[] = {
38258 (char *) "self",(char *) "n", NULL
38259 };
38260
38261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38263 if (SWIG_arg_fail(1)) SWIG_fail;
38264 {
38265 arg2 = (int)(SWIG_As_int(obj1));
38266 if (SWIG_arg_fail(2)) SWIG_fail;
38267 }
38268 {
38269 PyThreadState* __tstate = wxPyBeginAllowThreads();
38270 (arg1)->SetSelection(arg2);
38271
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 Py_INCREF(Py_None); resultobj = Py_None;
38276 return resultobj;
38277 fail:
38278 return NULL;
38279 }
38280
38281
38282 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38283 PyObject *resultobj;
38284 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38285 int result;
38286 PyObject * obj0 = 0 ;
38287 char *kwnames[] = {
38288 (char *) "self", NULL
38289 };
38290
38291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38293 if (SWIG_arg_fail(1)) SWIG_fail;
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38297
38298 wxPyEndAllowThreads(__tstate);
38299 if (PyErr_Occurred()) SWIG_fail;
38300 }
38301 {
38302 resultobj = SWIG_From_int((int)(result));
38303 }
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38311 PyObject *resultobj;
38312 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38313 wxString *arg2 = 0 ;
38314 bool result;
38315 bool temp2 = false ;
38316 PyObject * obj0 = 0 ;
38317 PyObject * obj1 = 0 ;
38318 char *kwnames[] = {
38319 (char *) "self",(char *) "s", NULL
38320 };
38321
38322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38324 if (SWIG_arg_fail(1)) SWIG_fail;
38325 {
38326 arg2 = wxString_in_helper(obj1);
38327 if (arg2 == NULL) SWIG_fail;
38328 temp2 = true;
38329 }
38330 {
38331 PyThreadState* __tstate = wxPyBeginAllowThreads();
38332 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38333
38334 wxPyEndAllowThreads(__tstate);
38335 if (PyErr_Occurred()) SWIG_fail;
38336 }
38337 {
38338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38339 }
38340 {
38341 if (temp2)
38342 delete arg2;
38343 }
38344 return resultobj;
38345 fail:
38346 {
38347 if (temp2)
38348 delete arg2;
38349 }
38350 return NULL;
38351 }
38352
38353
38354 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38355 PyObject *resultobj;
38356 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38357 wxString result;
38358 PyObject * obj0 = 0 ;
38359 char *kwnames[] = {
38360 (char *) "self", NULL
38361 };
38362
38363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38365 if (SWIG_arg_fail(1)) SWIG_fail;
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38369
38370 wxPyEndAllowThreads(__tstate);
38371 if (PyErr_Occurred()) SWIG_fail;
38372 }
38373 {
38374 #if wxUSE_UNICODE
38375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38376 #else
38377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38378 #endif
38379 }
38380 return resultobj;
38381 fail:
38382 return NULL;
38383 }
38384
38385
38386 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38387 PyObject *resultobj;
38388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38389 int arg2 ;
38390 PyObject * obj0 = 0 ;
38391 PyObject * obj1 = 0 ;
38392 char *kwnames[] = {
38393 (char *) "self",(char *) "n", NULL
38394 };
38395
38396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38398 if (SWIG_arg_fail(1)) SWIG_fail;
38399 {
38400 arg2 = (int)(SWIG_As_int(obj1));
38401 if (SWIG_arg_fail(2)) SWIG_fail;
38402 }
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 (arg1)->Select(arg2);
38406
38407 wxPyEndAllowThreads(__tstate);
38408 if (PyErr_Occurred()) SWIG_fail;
38409 }
38410 Py_INCREF(Py_None); resultobj = Py_None;
38411 return resultobj;
38412 fail:
38413 return NULL;
38414 }
38415
38416
38417 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38418 PyObject *obj;
38419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38420 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38421 Py_INCREF(obj);
38422 return Py_BuildValue((char *)"");
38423 }
38424 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38425 PyObject *obj;
38426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38427 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38428 Py_INCREF(obj);
38429 return Py_BuildValue((char *)"");
38430 }
38431 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38432 PyObject *resultobj;
38433 wxSizerItem *result;
38434 char *kwnames[] = {
38435 NULL
38436 };
38437
38438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38439 {
38440 PyThreadState* __tstate = wxPyBeginAllowThreads();
38441 result = (wxSizerItem *)new wxSizerItem();
38442
38443 wxPyEndAllowThreads(__tstate);
38444 if (PyErr_Occurred()) SWIG_fail;
38445 }
38446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj;
38455 wxWindow *arg1 = (wxWindow *) 0 ;
38456 int arg2 ;
38457 int arg3 ;
38458 int arg4 ;
38459 PyObject *arg5 = (PyObject *) NULL ;
38460 wxSizerItem *result;
38461 PyObject * obj0 = 0 ;
38462 PyObject * obj1 = 0 ;
38463 PyObject * obj2 = 0 ;
38464 PyObject * obj3 = 0 ;
38465 PyObject * obj4 = 0 ;
38466 char *kwnames[] = {
38467 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38468 };
38469
38470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38472 if (SWIG_arg_fail(1)) SWIG_fail;
38473 {
38474 arg2 = (int)(SWIG_As_int(obj1));
38475 if (SWIG_arg_fail(2)) SWIG_fail;
38476 }
38477 {
38478 arg3 = (int)(SWIG_As_int(obj2));
38479 if (SWIG_arg_fail(3)) SWIG_fail;
38480 }
38481 {
38482 arg4 = (int)(SWIG_As_int(obj3));
38483 if (SWIG_arg_fail(4)) SWIG_fail;
38484 }
38485 if (obj4) {
38486 arg5 = obj4;
38487 }
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38491
38492 wxPyEndAllowThreads(__tstate);
38493 if (PyErr_Occurred()) SWIG_fail;
38494 }
38495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38496 return resultobj;
38497 fail:
38498 return NULL;
38499 }
38500
38501
38502 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38503 PyObject *resultobj;
38504 int arg1 ;
38505 int arg2 ;
38506 int arg3 ;
38507 int arg4 ;
38508 int arg5 ;
38509 PyObject *arg6 = (PyObject *) NULL ;
38510 wxSizerItem *result;
38511 PyObject * obj0 = 0 ;
38512 PyObject * obj1 = 0 ;
38513 PyObject * obj2 = 0 ;
38514 PyObject * obj3 = 0 ;
38515 PyObject * obj4 = 0 ;
38516 PyObject * obj5 = 0 ;
38517 char *kwnames[] = {
38518 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38519 };
38520
38521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38522 {
38523 arg1 = (int)(SWIG_As_int(obj0));
38524 if (SWIG_arg_fail(1)) SWIG_fail;
38525 }
38526 {
38527 arg2 = (int)(SWIG_As_int(obj1));
38528 if (SWIG_arg_fail(2)) SWIG_fail;
38529 }
38530 {
38531 arg3 = (int)(SWIG_As_int(obj2));
38532 if (SWIG_arg_fail(3)) SWIG_fail;
38533 }
38534 {
38535 arg4 = (int)(SWIG_As_int(obj3));
38536 if (SWIG_arg_fail(4)) SWIG_fail;
38537 }
38538 {
38539 arg5 = (int)(SWIG_As_int(obj4));
38540 if (SWIG_arg_fail(5)) SWIG_fail;
38541 }
38542 if (obj5) {
38543 arg6 = obj5;
38544 }
38545 {
38546 PyThreadState* __tstate = wxPyBeginAllowThreads();
38547 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38548
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj;
38561 wxSizer *arg1 = (wxSizer *) 0 ;
38562 int arg2 ;
38563 int arg3 ;
38564 int arg4 ;
38565 PyObject *arg5 = (PyObject *) NULL ;
38566 wxSizerItem *result;
38567 PyObject * obj0 = 0 ;
38568 PyObject * obj1 = 0 ;
38569 PyObject * obj2 = 0 ;
38570 PyObject * obj3 = 0 ;
38571 PyObject * obj4 = 0 ;
38572 char *kwnames[] = {
38573 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38574 };
38575
38576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38578 if (SWIG_arg_fail(1)) SWIG_fail;
38579 {
38580 arg2 = (int)(SWIG_As_int(obj1));
38581 if (SWIG_arg_fail(2)) SWIG_fail;
38582 }
38583 {
38584 arg3 = (int)(SWIG_As_int(obj2));
38585 if (SWIG_arg_fail(3)) SWIG_fail;
38586 }
38587 {
38588 arg4 = (int)(SWIG_As_int(obj3));
38589 if (SWIG_arg_fail(4)) SWIG_fail;
38590 }
38591 if (obj4) {
38592 arg5 = obj4;
38593 }
38594 {
38595 PyThreadState* __tstate = wxPyBeginAllowThreads();
38596 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38597
38598 wxPyEndAllowThreads(__tstate);
38599 if (PyErr_Occurred()) SWIG_fail;
38600 }
38601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38609 PyObject *resultobj;
38610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38611 PyObject * obj0 = 0 ;
38612 char *kwnames[] = {
38613 (char *) "self", NULL
38614 };
38615
38616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38618 if (SWIG_arg_fail(1)) SWIG_fail;
38619 {
38620 PyThreadState* __tstate = wxPyBeginAllowThreads();
38621 (arg1)->DeleteWindows();
38622
38623 wxPyEndAllowThreads(__tstate);
38624 if (PyErr_Occurred()) SWIG_fail;
38625 }
38626 Py_INCREF(Py_None); resultobj = Py_None;
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38634 PyObject *resultobj;
38635 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38636 PyObject * obj0 = 0 ;
38637 char *kwnames[] = {
38638 (char *) "self", NULL
38639 };
38640
38641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38643 if (SWIG_arg_fail(1)) SWIG_fail;
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 (arg1)->DetachSizer();
38647
38648 wxPyEndAllowThreads(__tstate);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 }
38651 Py_INCREF(Py_None); resultobj = Py_None;
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj;
38660 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38661 wxSize result;
38662 PyObject * obj0 = 0 ;
38663 char *kwnames[] = {
38664 (char *) "self", NULL
38665 };
38666
38667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38669 if (SWIG_arg_fail(1)) SWIG_fail;
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = (arg1)->GetSize();
38673
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 {
38678 wxSize * resultptr;
38679 resultptr = new wxSize((wxSize &)(result));
38680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38681 }
38682 return resultobj;
38683 fail:
38684 return NULL;
38685 }
38686
38687
38688 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38689 PyObject *resultobj;
38690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38691 wxSize result;
38692 PyObject * obj0 = 0 ;
38693 char *kwnames[] = {
38694 (char *) "self", NULL
38695 };
38696
38697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38699 if (SWIG_arg_fail(1)) SWIG_fail;
38700 {
38701 PyThreadState* __tstate = wxPyBeginAllowThreads();
38702 result = (arg1)->CalcMin();
38703
38704 wxPyEndAllowThreads(__tstate);
38705 if (PyErr_Occurred()) SWIG_fail;
38706 }
38707 {
38708 wxSize * resultptr;
38709 resultptr = new wxSize((wxSize &)(result));
38710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38711 }
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj;
38720 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38721 wxPoint arg2 ;
38722 wxSize arg3 ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 PyObject * obj2 = 0 ;
38726 char *kwnames[] = {
38727 (char *) "self",(char *) "pos",(char *) "size", NULL
38728 };
38729
38730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38732 if (SWIG_arg_fail(1)) SWIG_fail;
38733 {
38734 wxPoint * argp;
38735 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38736 if (SWIG_arg_fail(2)) SWIG_fail;
38737 if (argp == NULL) {
38738 SWIG_null_ref("wxPoint");
38739 }
38740 if (SWIG_arg_fail(2)) SWIG_fail;
38741 arg2 = *argp;
38742 }
38743 {
38744 wxSize * argp;
38745 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38746 if (SWIG_arg_fail(3)) SWIG_fail;
38747 if (argp == NULL) {
38748 SWIG_null_ref("wxSize");
38749 }
38750 if (SWIG_arg_fail(3)) SWIG_fail;
38751 arg3 = *argp;
38752 }
38753 {
38754 PyThreadState* __tstate = wxPyBeginAllowThreads();
38755 (arg1)->SetDimension(arg2,arg3);
38756
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 Py_INCREF(Py_None); resultobj = Py_None;
38761 return resultobj;
38762 fail:
38763 return NULL;
38764 }
38765
38766
38767 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38768 PyObject *resultobj;
38769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38770 wxSize result;
38771 PyObject * obj0 = 0 ;
38772 char *kwnames[] = {
38773 (char *) "self", NULL
38774 };
38775
38776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38778 if (SWIG_arg_fail(1)) SWIG_fail;
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (arg1)->GetMinSize();
38782
38783 wxPyEndAllowThreads(__tstate);
38784 if (PyErr_Occurred()) SWIG_fail;
38785 }
38786 {
38787 wxSize * resultptr;
38788 resultptr = new wxSize((wxSize &)(result));
38789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38790 }
38791 return resultobj;
38792 fail:
38793 return NULL;
38794 }
38795
38796
38797 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38798 PyObject *resultobj;
38799 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38800 wxSize result;
38801 PyObject * obj0 = 0 ;
38802 char *kwnames[] = {
38803 (char *) "self", NULL
38804 };
38805
38806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38808 if (SWIG_arg_fail(1)) SWIG_fail;
38809 {
38810 PyThreadState* __tstate = wxPyBeginAllowThreads();
38811 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38812
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 {
38817 wxSize * resultptr;
38818 resultptr = new wxSize((wxSize &)(result));
38819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38820 }
38821 return resultobj;
38822 fail:
38823 return NULL;
38824 }
38825
38826
38827 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38828 PyObject *resultobj;
38829 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38830 int arg2 ;
38831 int arg3 ;
38832 PyObject * obj0 = 0 ;
38833 PyObject * obj1 = 0 ;
38834 PyObject * obj2 = 0 ;
38835 char *kwnames[] = {
38836 (char *) "self",(char *) "x",(char *) "y", NULL
38837 };
38838
38839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38841 if (SWIG_arg_fail(1)) SWIG_fail;
38842 {
38843 arg2 = (int)(SWIG_As_int(obj1));
38844 if (SWIG_arg_fail(2)) SWIG_fail;
38845 }
38846 {
38847 arg3 = (int)(SWIG_As_int(obj2));
38848 if (SWIG_arg_fail(3)) SWIG_fail;
38849 }
38850 {
38851 PyThreadState* __tstate = wxPyBeginAllowThreads();
38852 (arg1)->SetInitSize(arg2,arg3);
38853
38854 wxPyEndAllowThreads(__tstate);
38855 if (PyErr_Occurred()) SWIG_fail;
38856 }
38857 Py_INCREF(Py_None); resultobj = Py_None;
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj;
38866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38867 int arg2 ;
38868 int arg3 ;
38869 PyObject * obj0 = 0 ;
38870 PyObject * obj1 = 0 ;
38871 PyObject * obj2 = 0 ;
38872 char *kwnames[] = {
38873 (char *) "self",(char *) "width",(char *) "height", NULL
38874 };
38875
38876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38878 if (SWIG_arg_fail(1)) SWIG_fail;
38879 {
38880 arg2 = (int)(SWIG_As_int(obj1));
38881 if (SWIG_arg_fail(2)) SWIG_fail;
38882 }
38883 {
38884 arg3 = (int)(SWIG_As_int(obj2));
38885 if (SWIG_arg_fail(3)) SWIG_fail;
38886 }
38887 {
38888 PyThreadState* __tstate = wxPyBeginAllowThreads();
38889 (arg1)->SetRatio(arg2,arg3);
38890
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 Py_INCREF(Py_None); resultobj = Py_None;
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj;
38903 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38904 wxSize *arg2 = 0 ;
38905 wxSize temp2 ;
38906 PyObject * obj0 = 0 ;
38907 PyObject * obj1 = 0 ;
38908 char *kwnames[] = {
38909 (char *) "self",(char *) "size", NULL
38910 };
38911
38912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38914 if (SWIG_arg_fail(1)) SWIG_fail;
38915 {
38916 arg2 = &temp2;
38917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38918 }
38919 {
38920 PyThreadState* __tstate = wxPyBeginAllowThreads();
38921 (arg1)->SetRatio((wxSize const &)*arg2);
38922
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 Py_INCREF(Py_None); resultobj = Py_None;
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj;
38935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38936 float arg2 ;
38937 PyObject * obj0 = 0 ;
38938 PyObject * obj1 = 0 ;
38939 char *kwnames[] = {
38940 (char *) "self",(char *) "ratio", NULL
38941 };
38942
38943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38945 if (SWIG_arg_fail(1)) SWIG_fail;
38946 {
38947 arg2 = (float)(SWIG_As_float(obj1));
38948 if (SWIG_arg_fail(2)) SWIG_fail;
38949 }
38950 {
38951 PyThreadState* __tstate = wxPyBeginAllowThreads();
38952 (arg1)->SetRatio(arg2);
38953
38954 wxPyEndAllowThreads(__tstate);
38955 if (PyErr_Occurred()) SWIG_fail;
38956 }
38957 Py_INCREF(Py_None); resultobj = Py_None;
38958 return resultobj;
38959 fail:
38960 return NULL;
38961 }
38962
38963
38964 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj;
38966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38967 float result;
38968 PyObject * obj0 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (float)(arg1)->GetRatio();
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = SWIG_From_float((float)(result));
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj;
38994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38995 wxRect result;
38996 PyObject * obj0 = 0 ;
38997 char *kwnames[] = {
38998 (char *) "self", NULL
38999 };
39000
39001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39003 if (SWIG_arg_fail(1)) SWIG_fail;
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (arg1)->GetRect();
39007
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 {
39012 wxRect * resultptr;
39013 resultptr = new wxRect((wxRect &)(result));
39014 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39015 }
39016 return resultobj;
39017 fail:
39018 return NULL;
39019 }
39020
39021
39022 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39023 PyObject *resultobj;
39024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39025 bool result;
39026 PyObject * obj0 = 0 ;
39027 char *kwnames[] = {
39028 (char *) "self", NULL
39029 };
39030
39031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39033 if (SWIG_arg_fail(1)) SWIG_fail;
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = (bool)(arg1)->IsWindow();
39037
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj;
39052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39053 bool result;
39054 PyObject * obj0 = 0 ;
39055 char *kwnames[] = {
39056 (char *) "self", NULL
39057 };
39058
39059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39061 if (SWIG_arg_fail(1)) SWIG_fail;
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 result = (bool)(arg1)->IsSizer();
39065
39066 wxPyEndAllowThreads(__tstate);
39067 if (PyErr_Occurred()) SWIG_fail;
39068 }
39069 {
39070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39071 }
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj;
39080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39081 bool result;
39082 PyObject * obj0 = 0 ;
39083 char *kwnames[] = {
39084 (char *) "self", NULL
39085 };
39086
39087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39089 if (SWIG_arg_fail(1)) SWIG_fail;
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = (bool)(arg1)->IsSpacer();
39093
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39099 }
39100 return resultobj;
39101 fail:
39102 return NULL;
39103 }
39104
39105
39106 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39107 PyObject *resultobj;
39108 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39109 int arg2 ;
39110 PyObject * obj0 = 0 ;
39111 PyObject * obj1 = 0 ;
39112 char *kwnames[] = {
39113 (char *) "self",(char *) "proportion", NULL
39114 };
39115
39116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39118 if (SWIG_arg_fail(1)) SWIG_fail;
39119 {
39120 arg2 = (int)(SWIG_As_int(obj1));
39121 if (SWIG_arg_fail(2)) SWIG_fail;
39122 }
39123 {
39124 PyThreadState* __tstate = wxPyBeginAllowThreads();
39125 (arg1)->SetProportion(arg2);
39126
39127 wxPyEndAllowThreads(__tstate);
39128 if (PyErr_Occurred()) SWIG_fail;
39129 }
39130 Py_INCREF(Py_None); resultobj = Py_None;
39131 return resultobj;
39132 fail:
39133 return NULL;
39134 }
39135
39136
39137 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39138 PyObject *resultobj;
39139 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39140 int result;
39141 PyObject * obj0 = 0 ;
39142 char *kwnames[] = {
39143 (char *) "self", NULL
39144 };
39145
39146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39148 if (SWIG_arg_fail(1)) SWIG_fail;
39149 {
39150 PyThreadState* __tstate = wxPyBeginAllowThreads();
39151 result = (int)(arg1)->GetProportion();
39152
39153 wxPyEndAllowThreads(__tstate);
39154 if (PyErr_Occurred()) SWIG_fail;
39155 }
39156 {
39157 resultobj = SWIG_From_int((int)(result));
39158 }
39159 return resultobj;
39160 fail:
39161 return NULL;
39162 }
39163
39164
39165 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39166 PyObject *resultobj;
39167 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39168 int arg2 ;
39169 PyObject * obj0 = 0 ;
39170 PyObject * obj1 = 0 ;
39171 char *kwnames[] = {
39172 (char *) "self",(char *) "flag", NULL
39173 };
39174
39175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39177 if (SWIG_arg_fail(1)) SWIG_fail;
39178 {
39179 arg2 = (int)(SWIG_As_int(obj1));
39180 if (SWIG_arg_fail(2)) SWIG_fail;
39181 }
39182 {
39183 PyThreadState* __tstate = wxPyBeginAllowThreads();
39184 (arg1)->SetFlag(arg2);
39185
39186 wxPyEndAllowThreads(__tstate);
39187 if (PyErr_Occurred()) SWIG_fail;
39188 }
39189 Py_INCREF(Py_None); resultobj = Py_None;
39190 return resultobj;
39191 fail:
39192 return NULL;
39193 }
39194
39195
39196 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39197 PyObject *resultobj;
39198 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39199 int result;
39200 PyObject * obj0 = 0 ;
39201 char *kwnames[] = {
39202 (char *) "self", NULL
39203 };
39204
39205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39207 if (SWIG_arg_fail(1)) SWIG_fail;
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = (int)(arg1)->GetFlag();
39211
39212 wxPyEndAllowThreads(__tstate);
39213 if (PyErr_Occurred()) SWIG_fail;
39214 }
39215 {
39216 resultobj = SWIG_From_int((int)(result));
39217 }
39218 return resultobj;
39219 fail:
39220 return NULL;
39221 }
39222
39223
39224 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39225 PyObject *resultobj;
39226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39227 int arg2 ;
39228 PyObject * obj0 = 0 ;
39229 PyObject * obj1 = 0 ;
39230 char *kwnames[] = {
39231 (char *) "self",(char *) "border", NULL
39232 };
39233
39234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39236 if (SWIG_arg_fail(1)) SWIG_fail;
39237 {
39238 arg2 = (int)(SWIG_As_int(obj1));
39239 if (SWIG_arg_fail(2)) SWIG_fail;
39240 }
39241 {
39242 PyThreadState* __tstate = wxPyBeginAllowThreads();
39243 (arg1)->SetBorder(arg2);
39244
39245 wxPyEndAllowThreads(__tstate);
39246 if (PyErr_Occurred()) SWIG_fail;
39247 }
39248 Py_INCREF(Py_None); resultobj = Py_None;
39249 return resultobj;
39250 fail:
39251 return NULL;
39252 }
39253
39254
39255 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39256 PyObject *resultobj;
39257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39258 int result;
39259 PyObject * obj0 = 0 ;
39260 char *kwnames[] = {
39261 (char *) "self", NULL
39262 };
39263
39264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39266 if (SWIG_arg_fail(1)) SWIG_fail;
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 result = (int)(arg1)->GetBorder();
39270
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 {
39275 resultobj = SWIG_From_int((int)(result));
39276 }
39277 return resultobj;
39278 fail:
39279 return NULL;
39280 }
39281
39282
39283 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39284 PyObject *resultobj;
39285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39286 wxWindow *result;
39287 PyObject * obj0 = 0 ;
39288 char *kwnames[] = {
39289 (char *) "self", NULL
39290 };
39291
39292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39294 if (SWIG_arg_fail(1)) SWIG_fail;
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (wxWindow *)(arg1)->GetWindow();
39298
39299 wxPyEndAllowThreads(__tstate);
39300 if (PyErr_Occurred()) SWIG_fail;
39301 }
39302 {
39303 resultobj = wxPyMake_wxObject(result, 0);
39304 }
39305 return resultobj;
39306 fail:
39307 return NULL;
39308 }
39309
39310
39311 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39312 PyObject *resultobj;
39313 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39314 wxWindow *arg2 = (wxWindow *) 0 ;
39315 PyObject * obj0 = 0 ;
39316 PyObject * obj1 = 0 ;
39317 char *kwnames[] = {
39318 (char *) "self",(char *) "window", NULL
39319 };
39320
39321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39323 if (SWIG_arg_fail(1)) SWIG_fail;
39324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39325 if (SWIG_arg_fail(2)) SWIG_fail;
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 (arg1)->SetWindow(arg2);
39329
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 Py_INCREF(Py_None); resultobj = Py_None;
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj;
39342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39343 wxSizer *result;
39344 PyObject * obj0 = 0 ;
39345 char *kwnames[] = {
39346 (char *) "self", NULL
39347 };
39348
39349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39351 if (SWIG_arg_fail(1)) SWIG_fail;
39352 {
39353 PyThreadState* __tstate = wxPyBeginAllowThreads();
39354 result = (wxSizer *)(arg1)->GetSizer();
39355
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 {
39360 resultobj = wxPyMake_wxObject(result, 0);
39361 }
39362 return resultobj;
39363 fail:
39364 return NULL;
39365 }
39366
39367
39368 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj;
39370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39371 wxSizer *arg2 = (wxSizer *) 0 ;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 char *kwnames[] = {
39375 (char *) "self",(char *) "sizer", NULL
39376 };
39377
39378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39380 if (SWIG_arg_fail(1)) SWIG_fail;
39381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39382 if (SWIG_arg_fail(2)) SWIG_fail;
39383 {
39384 PyThreadState* __tstate = wxPyBeginAllowThreads();
39385 (arg1)->SetSizer(arg2);
39386
39387 wxPyEndAllowThreads(__tstate);
39388 if (PyErr_Occurred()) SWIG_fail;
39389 }
39390 Py_INCREF(Py_None); resultobj = Py_None;
39391 return resultobj;
39392 fail:
39393 return NULL;
39394 }
39395
39396
39397 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39398 PyObject *resultobj;
39399 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39400 wxSize *result;
39401 PyObject * obj0 = 0 ;
39402 char *kwnames[] = {
39403 (char *) "self", NULL
39404 };
39405
39406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39408 if (SWIG_arg_fail(1)) SWIG_fail;
39409 {
39410 PyThreadState* __tstate = wxPyBeginAllowThreads();
39411 {
39412 wxSize const &_result_ref = (arg1)->GetSpacer();
39413 result = (wxSize *) &_result_ref;
39414 }
39415
39416 wxPyEndAllowThreads(__tstate);
39417 if (PyErr_Occurred()) SWIG_fail;
39418 }
39419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39420 return resultobj;
39421 fail:
39422 return NULL;
39423 }
39424
39425
39426 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39427 PyObject *resultobj;
39428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39429 wxSize *arg2 = 0 ;
39430 wxSize temp2 ;
39431 PyObject * obj0 = 0 ;
39432 PyObject * obj1 = 0 ;
39433 char *kwnames[] = {
39434 (char *) "self",(char *) "size", NULL
39435 };
39436
39437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39439 if (SWIG_arg_fail(1)) SWIG_fail;
39440 {
39441 arg2 = &temp2;
39442 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39443 }
39444 {
39445 PyThreadState* __tstate = wxPyBeginAllowThreads();
39446 (arg1)->SetSpacer((wxSize const &)*arg2);
39447
39448 wxPyEndAllowThreads(__tstate);
39449 if (PyErr_Occurred()) SWIG_fail;
39450 }
39451 Py_INCREF(Py_None); resultobj = Py_None;
39452 return resultobj;
39453 fail:
39454 return NULL;
39455 }
39456
39457
39458 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39459 PyObject *resultobj;
39460 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39461 bool arg2 ;
39462 PyObject * obj0 = 0 ;
39463 PyObject * obj1 = 0 ;
39464 char *kwnames[] = {
39465 (char *) "self",(char *) "show", NULL
39466 };
39467
39468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39470 if (SWIG_arg_fail(1)) SWIG_fail;
39471 {
39472 arg2 = (bool)(SWIG_As_bool(obj1));
39473 if (SWIG_arg_fail(2)) SWIG_fail;
39474 }
39475 {
39476 PyThreadState* __tstate = wxPyBeginAllowThreads();
39477 (arg1)->Show(arg2);
39478
39479 wxPyEndAllowThreads(__tstate);
39480 if (PyErr_Occurred()) SWIG_fail;
39481 }
39482 Py_INCREF(Py_None); resultobj = Py_None;
39483 return resultobj;
39484 fail:
39485 return NULL;
39486 }
39487
39488
39489 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39490 PyObject *resultobj;
39491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39492 bool result;
39493 PyObject * obj0 = 0 ;
39494 char *kwnames[] = {
39495 (char *) "self", NULL
39496 };
39497
39498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39500 if (SWIG_arg_fail(1)) SWIG_fail;
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 result = (bool)(arg1)->IsShown();
39504
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 {
39509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39510 }
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39518 PyObject *resultobj;
39519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39520 wxPoint result;
39521 PyObject * obj0 = 0 ;
39522 char *kwnames[] = {
39523 (char *) "self", NULL
39524 };
39525
39526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39528 if (SWIG_arg_fail(1)) SWIG_fail;
39529 {
39530 PyThreadState* __tstate = wxPyBeginAllowThreads();
39531 result = (arg1)->GetPosition();
39532
39533 wxPyEndAllowThreads(__tstate);
39534 if (PyErr_Occurred()) SWIG_fail;
39535 }
39536 {
39537 wxPoint * resultptr;
39538 resultptr = new wxPoint((wxPoint &)(result));
39539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39540 }
39541 return resultobj;
39542 fail:
39543 return NULL;
39544 }
39545
39546
39547 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39548 PyObject *resultobj;
39549 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39550 PyObject *result;
39551 PyObject * obj0 = 0 ;
39552 char *kwnames[] = {
39553 (char *) "self", NULL
39554 };
39555
39556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39558 if (SWIG_arg_fail(1)) SWIG_fail;
39559 {
39560 PyThreadState* __tstate = wxPyBeginAllowThreads();
39561 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39562
39563 wxPyEndAllowThreads(__tstate);
39564 if (PyErr_Occurred()) SWIG_fail;
39565 }
39566 resultobj = result;
39567 return resultobj;
39568 fail:
39569 return NULL;
39570 }
39571
39572
39573 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39574 PyObject *obj;
39575 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39576 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39577 Py_INCREF(obj);
39578 return Py_BuildValue((char *)"");
39579 }
39580 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39581 PyObject *resultobj;
39582 wxSizer *arg1 = (wxSizer *) 0 ;
39583 PyObject *arg2 = (PyObject *) 0 ;
39584 PyObject * obj0 = 0 ;
39585 PyObject * obj1 = 0 ;
39586 char *kwnames[] = {
39587 (char *) "self",(char *) "_self", NULL
39588 };
39589
39590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39592 if (SWIG_arg_fail(1)) SWIG_fail;
39593 arg2 = obj1;
39594 {
39595 PyThreadState* __tstate = wxPyBeginAllowThreads();
39596 wxSizer__setOORInfo(arg1,arg2);
39597
39598 wxPyEndAllowThreads(__tstate);
39599 if (PyErr_Occurred()) SWIG_fail;
39600 }
39601 Py_INCREF(Py_None); resultobj = Py_None;
39602 return resultobj;
39603 fail:
39604 return NULL;
39605 }
39606
39607
39608 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj;
39610 wxSizer *arg1 = (wxSizer *) 0 ;
39611 PyObject *arg2 = (PyObject *) 0 ;
39612 int arg3 = (int) 0 ;
39613 int arg4 = (int) 0 ;
39614 int arg5 = (int) 0 ;
39615 PyObject *arg6 = (PyObject *) NULL ;
39616 wxSizerItem *result;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 PyObject * obj2 = 0 ;
39620 PyObject * obj3 = 0 ;
39621 PyObject * obj4 = 0 ;
39622 PyObject * obj5 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 arg2 = obj1;
39631 if (obj2) {
39632 {
39633 arg3 = (int)(SWIG_As_int(obj2));
39634 if (SWIG_arg_fail(3)) SWIG_fail;
39635 }
39636 }
39637 if (obj3) {
39638 {
39639 arg4 = (int)(SWIG_As_int(obj3));
39640 if (SWIG_arg_fail(4)) SWIG_fail;
39641 }
39642 }
39643 if (obj4) {
39644 {
39645 arg5 = (int)(SWIG_As_int(obj4));
39646 if (SWIG_arg_fail(5)) SWIG_fail;
39647 }
39648 }
39649 if (obj5) {
39650 arg6 = obj5;
39651 }
39652 {
39653 PyThreadState* __tstate = wxPyBeginAllowThreads();
39654 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
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_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39667 PyObject *resultobj;
39668 wxSizer *arg1 = (wxSizer *) 0 ;
39669 int arg2 ;
39670 PyObject *arg3 = (PyObject *) 0 ;
39671 int arg4 = (int) 0 ;
39672 int arg5 = (int) 0 ;
39673 int arg6 = (int) 0 ;
39674 PyObject *arg7 = (PyObject *) NULL ;
39675 wxSizerItem *result;
39676 PyObject * obj0 = 0 ;
39677 PyObject * obj1 = 0 ;
39678 PyObject * obj2 = 0 ;
39679 PyObject * obj3 = 0 ;
39680 PyObject * obj4 = 0 ;
39681 PyObject * obj5 = 0 ;
39682 PyObject * obj6 = 0 ;
39683 char *kwnames[] = {
39684 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39685 };
39686
39687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39689 if (SWIG_arg_fail(1)) SWIG_fail;
39690 {
39691 arg2 = (int)(SWIG_As_int(obj1));
39692 if (SWIG_arg_fail(2)) SWIG_fail;
39693 }
39694 arg3 = obj2;
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 {
39709 arg6 = (int)(SWIG_As_int(obj5));
39710 if (SWIG_arg_fail(6)) SWIG_fail;
39711 }
39712 }
39713 if (obj6) {
39714 arg7 = obj6;
39715 }
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39719
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39724 return resultobj;
39725 fail:
39726 return NULL;
39727 }
39728
39729
39730 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39731 PyObject *resultobj;
39732 wxSizer *arg1 = (wxSizer *) 0 ;
39733 PyObject *arg2 = (PyObject *) 0 ;
39734 int arg3 = (int) 0 ;
39735 int arg4 = (int) 0 ;
39736 int arg5 = (int) 0 ;
39737 PyObject *arg6 = (PyObject *) NULL ;
39738 wxSizerItem *result;
39739 PyObject * obj0 = 0 ;
39740 PyObject * obj1 = 0 ;
39741 PyObject * obj2 = 0 ;
39742 PyObject * obj3 = 0 ;
39743 PyObject * obj4 = 0 ;
39744 PyObject * obj5 = 0 ;
39745 char *kwnames[] = {
39746 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39747 };
39748
39749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39751 if (SWIG_arg_fail(1)) SWIG_fail;
39752 arg2 = obj1;
39753 if (obj2) {
39754 {
39755 arg3 = (int)(SWIG_As_int(obj2));
39756 if (SWIG_arg_fail(3)) SWIG_fail;
39757 }
39758 }
39759 if (obj3) {
39760 {
39761 arg4 = (int)(SWIG_As_int(obj3));
39762 if (SWIG_arg_fail(4)) SWIG_fail;
39763 }
39764 }
39765 if (obj4) {
39766 {
39767 arg5 = (int)(SWIG_As_int(obj4));
39768 if (SWIG_arg_fail(5)) SWIG_fail;
39769 }
39770 }
39771 if (obj5) {
39772 arg6 = obj5;
39773 }
39774 {
39775 PyThreadState* __tstate = wxPyBeginAllowThreads();
39776 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39777
39778 wxPyEndAllowThreads(__tstate);
39779 if (PyErr_Occurred()) SWIG_fail;
39780 }
39781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39782 return resultobj;
39783 fail:
39784 return NULL;
39785 }
39786
39787
39788 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39789 PyObject *resultobj;
39790 wxSizer *arg1 = (wxSizer *) 0 ;
39791 PyObject *arg2 = (PyObject *) 0 ;
39792 bool result;
39793 PyObject * obj0 = 0 ;
39794 PyObject * obj1 = 0 ;
39795 char *kwnames[] = {
39796 (char *) "self",(char *) "item", NULL
39797 };
39798
39799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39801 if (SWIG_arg_fail(1)) SWIG_fail;
39802 arg2 = obj1;
39803 {
39804 PyThreadState* __tstate = wxPyBeginAllowThreads();
39805 result = (bool)wxSizer_Remove(arg1,arg2);
39806
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 {
39811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39812 }
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39820 PyObject *resultobj;
39821 wxSizer *arg1 = (wxSizer *) 0 ;
39822 PyObject *arg2 = (PyObject *) 0 ;
39823 bool result;
39824 PyObject * obj0 = 0 ;
39825 PyObject * obj1 = 0 ;
39826 char *kwnames[] = {
39827 (char *) "self",(char *) "item", NULL
39828 };
39829
39830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39832 if (SWIG_arg_fail(1)) SWIG_fail;
39833 arg2 = obj1;
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 result = (bool)wxSizer_Detach(arg1,arg2);
39837
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 {
39842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39843 }
39844 return resultobj;
39845 fail:
39846 return NULL;
39847 }
39848
39849
39850 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39851 PyObject *resultobj;
39852 wxSizer *arg1 = (wxSizer *) 0 ;
39853 PyObject *arg2 = (PyObject *) 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_GetItem",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 arg2 = obj1;
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39868
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39873 return resultobj;
39874 fail:
39875 return NULL;
39876 }
39877
39878
39879 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39880 PyObject *resultobj;
39881 wxSizer *arg1 = (wxSizer *) 0 ;
39882 PyObject *arg2 = (PyObject *) 0 ;
39883 wxSize *arg3 = 0 ;
39884 wxSize temp3 ;
39885 PyObject * obj0 = 0 ;
39886 PyObject * obj1 = 0 ;
39887 PyObject * obj2 = 0 ;
39888 char *kwnames[] = {
39889 (char *) "self",(char *) "item",(char *) "size", NULL
39890 };
39891
39892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39894 if (SWIG_arg_fail(1)) SWIG_fail;
39895 arg2 = obj1;
39896 {
39897 arg3 = &temp3;
39898 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39899 }
39900 {
39901 PyThreadState* __tstate = wxPyBeginAllowThreads();
39902 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39903
39904 wxPyEndAllowThreads(__tstate);
39905 if (PyErr_Occurred()) SWIG_fail;
39906 }
39907 Py_INCREF(Py_None); resultobj = Py_None;
39908 return resultobj;
39909 fail:
39910 return NULL;
39911 }
39912
39913
39914 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39915 PyObject *resultobj;
39916 wxSizer *arg1 = (wxSizer *) 0 ;
39917 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39918 wxSizerItem *result;
39919 PyObject * obj0 = 0 ;
39920 PyObject * obj1 = 0 ;
39921 char *kwnames[] = {
39922 (char *) "self",(char *) "item", NULL
39923 };
39924
39925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39927 if (SWIG_arg_fail(1)) SWIG_fail;
39928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39929 if (SWIG_arg_fail(2)) SWIG_fail;
39930 {
39931 PyThreadState* __tstate = wxPyBeginAllowThreads();
39932 result = (wxSizerItem *)(arg1)->Add(arg2);
39933
39934 wxPyEndAllowThreads(__tstate);
39935 if (PyErr_Occurred()) SWIG_fail;
39936 }
39937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39938 return resultobj;
39939 fail:
39940 return NULL;
39941 }
39942
39943
39944 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39945 PyObject *resultobj;
39946 wxSizer *arg1 = (wxSizer *) 0 ;
39947 size_t arg2 ;
39948 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39949 wxSizerItem *result;
39950 PyObject * obj0 = 0 ;
39951 PyObject * obj1 = 0 ;
39952 PyObject * obj2 = 0 ;
39953 char *kwnames[] = {
39954 (char *) "self",(char *) "index",(char *) "item", NULL
39955 };
39956
39957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39959 if (SWIG_arg_fail(1)) SWIG_fail;
39960 {
39961 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39962 if (SWIG_arg_fail(2)) SWIG_fail;
39963 }
39964 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39965 if (SWIG_arg_fail(3)) SWIG_fail;
39966 {
39967 PyThreadState* __tstate = wxPyBeginAllowThreads();
39968 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39969
39970 wxPyEndAllowThreads(__tstate);
39971 if (PyErr_Occurred()) SWIG_fail;
39972 }
39973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39974 return resultobj;
39975 fail:
39976 return NULL;
39977 }
39978
39979
39980 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39981 PyObject *resultobj;
39982 wxSizer *arg1 = (wxSizer *) 0 ;
39983 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39984 wxSizerItem *result;
39985 PyObject * obj0 = 0 ;
39986 PyObject * obj1 = 0 ;
39987 char *kwnames[] = {
39988 (char *) "self",(char *) "item", NULL
39989 };
39990
39991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39993 if (SWIG_arg_fail(1)) SWIG_fail;
39994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39995 if (SWIG_arg_fail(2)) SWIG_fail;
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39999
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40004 return resultobj;
40005 fail:
40006 return NULL;
40007 }
40008
40009
40010 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40011 PyObject *resultobj;
40012 wxSizer *arg1 = (wxSizer *) 0 ;
40013 int arg2 ;
40014 int arg3 ;
40015 int arg4 ;
40016 int arg5 ;
40017 PyObject * obj0 = 0 ;
40018 PyObject * obj1 = 0 ;
40019 PyObject * obj2 = 0 ;
40020 PyObject * obj3 = 0 ;
40021 PyObject * obj4 = 0 ;
40022 char *kwnames[] = {
40023 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40024 };
40025
40026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40028 if (SWIG_arg_fail(1)) SWIG_fail;
40029 {
40030 arg2 = (int)(SWIG_As_int(obj1));
40031 if (SWIG_arg_fail(2)) SWIG_fail;
40032 }
40033 {
40034 arg3 = (int)(SWIG_As_int(obj2));
40035 if (SWIG_arg_fail(3)) SWIG_fail;
40036 }
40037 {
40038 arg4 = (int)(SWIG_As_int(obj3));
40039 if (SWIG_arg_fail(4)) SWIG_fail;
40040 }
40041 {
40042 arg5 = (int)(SWIG_As_int(obj4));
40043 if (SWIG_arg_fail(5)) SWIG_fail;
40044 }
40045 {
40046 PyThreadState* __tstate = wxPyBeginAllowThreads();
40047 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40048
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 Py_INCREF(Py_None); resultobj = Py_None;
40053 return resultobj;
40054 fail:
40055 return NULL;
40056 }
40057
40058
40059 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40060 PyObject *resultobj;
40061 wxSizer *arg1 = (wxSizer *) 0 ;
40062 wxSize *arg2 = 0 ;
40063 wxSize temp2 ;
40064 PyObject * obj0 = 0 ;
40065 PyObject * obj1 = 0 ;
40066 char *kwnames[] = {
40067 (char *) "self",(char *) "size", NULL
40068 };
40069
40070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40072 if (SWIG_arg_fail(1)) SWIG_fail;
40073 {
40074 arg2 = &temp2;
40075 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40076 }
40077 {
40078 PyThreadState* __tstate = wxPyBeginAllowThreads();
40079 (arg1)->SetMinSize((wxSize const &)*arg2);
40080
40081 wxPyEndAllowThreads(__tstate);
40082 if (PyErr_Occurred()) SWIG_fail;
40083 }
40084 Py_INCREF(Py_None); resultobj = Py_None;
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40092 PyObject *resultobj;
40093 wxSizer *arg1 = (wxSizer *) 0 ;
40094 wxSize result;
40095 PyObject * obj0 = 0 ;
40096 char *kwnames[] = {
40097 (char *) "self", NULL
40098 };
40099
40100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40102 if (SWIG_arg_fail(1)) SWIG_fail;
40103 {
40104 PyThreadState* __tstate = wxPyBeginAllowThreads();
40105 result = (arg1)->GetSize();
40106
40107 wxPyEndAllowThreads(__tstate);
40108 if (PyErr_Occurred()) SWIG_fail;
40109 }
40110 {
40111 wxSize * resultptr;
40112 resultptr = new wxSize((wxSize &)(result));
40113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj;
40123 wxSizer *arg1 = (wxSizer *) 0 ;
40124 wxPoint result;
40125 PyObject * obj0 = 0 ;
40126 char *kwnames[] = {
40127 (char *) "self", NULL
40128 };
40129
40130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40132 if (SWIG_arg_fail(1)) SWIG_fail;
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (arg1)->GetPosition();
40136
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 {
40141 wxPoint * resultptr;
40142 resultptr = new wxPoint((wxPoint &)(result));
40143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40144 }
40145 return resultobj;
40146 fail:
40147 return NULL;
40148 }
40149
40150
40151 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40152 PyObject *resultobj;
40153 wxSizer *arg1 = (wxSizer *) 0 ;
40154 wxSize result;
40155 PyObject * obj0 = 0 ;
40156 char *kwnames[] = {
40157 (char *) "self", NULL
40158 };
40159
40160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40162 if (SWIG_arg_fail(1)) SWIG_fail;
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (arg1)->GetMinSize();
40166
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 {
40171 wxSize * resultptr;
40172 resultptr = new wxSize((wxSize &)(result));
40173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40174 }
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40182 PyObject *resultobj;
40183 wxSizer *arg1 = (wxSizer *) 0 ;
40184 PyObject * obj0 = 0 ;
40185 char *kwnames[] = {
40186 (char *) "self", NULL
40187 };
40188
40189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40191 if (SWIG_arg_fail(1)) SWIG_fail;
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 (arg1)->RecalcSizes();
40195
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 Py_INCREF(Py_None); resultobj = Py_None;
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40207 PyObject *resultobj;
40208 wxSizer *arg1 = (wxSizer *) 0 ;
40209 wxSize result;
40210 PyObject * obj0 = 0 ;
40211 char *kwnames[] = {
40212 (char *) "self", NULL
40213 };
40214
40215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40217 if (SWIG_arg_fail(1)) SWIG_fail;
40218 {
40219 PyThreadState* __tstate = wxPyBeginAllowThreads();
40220 result = (arg1)->CalcMin();
40221
40222 wxPyEndAllowThreads(__tstate);
40223 if (PyErr_Occurred()) SWIG_fail;
40224 }
40225 {
40226 wxSize * resultptr;
40227 resultptr = new wxSize((wxSize &)(result));
40228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40229 }
40230 return resultobj;
40231 fail:
40232 return NULL;
40233 }
40234
40235
40236 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40237 PyObject *resultobj;
40238 wxSizer *arg1 = (wxSizer *) 0 ;
40239 PyObject * obj0 = 0 ;
40240 char *kwnames[] = {
40241 (char *) "self", NULL
40242 };
40243
40244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40246 if (SWIG_arg_fail(1)) SWIG_fail;
40247 {
40248 PyThreadState* __tstate = wxPyBeginAllowThreads();
40249 (arg1)->Layout();
40250
40251 wxPyEndAllowThreads(__tstate);
40252 if (PyErr_Occurred()) SWIG_fail;
40253 }
40254 Py_INCREF(Py_None); resultobj = Py_None;
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40262 PyObject *resultobj;
40263 wxSizer *arg1 = (wxSizer *) 0 ;
40264 wxWindow *arg2 = (wxWindow *) 0 ;
40265 wxSize result;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 char *kwnames[] = {
40269 (char *) "self",(char *) "window", NULL
40270 };
40271
40272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40274 if (SWIG_arg_fail(1)) SWIG_fail;
40275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40276 if (SWIG_arg_fail(2)) SWIG_fail;
40277 {
40278 PyThreadState* __tstate = wxPyBeginAllowThreads();
40279 result = (arg1)->Fit(arg2);
40280
40281 wxPyEndAllowThreads(__tstate);
40282 if (PyErr_Occurred()) SWIG_fail;
40283 }
40284 {
40285 wxSize * resultptr;
40286 resultptr = new wxSize((wxSize &)(result));
40287 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40288 }
40289 return resultobj;
40290 fail:
40291 return NULL;
40292 }
40293
40294
40295 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40296 PyObject *resultobj;
40297 wxSizer *arg1 = (wxSizer *) 0 ;
40298 wxWindow *arg2 = (wxWindow *) 0 ;
40299 PyObject * obj0 = 0 ;
40300 PyObject * obj1 = 0 ;
40301 char *kwnames[] = {
40302 (char *) "self",(char *) "window", NULL
40303 };
40304
40305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40307 if (SWIG_arg_fail(1)) SWIG_fail;
40308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40309 if (SWIG_arg_fail(2)) SWIG_fail;
40310 {
40311 PyThreadState* __tstate = wxPyBeginAllowThreads();
40312 (arg1)->FitInside(arg2);
40313
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 Py_INCREF(Py_None); resultobj = Py_None;
40318 return resultobj;
40319 fail:
40320 return NULL;
40321 }
40322
40323
40324 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40325 PyObject *resultobj;
40326 wxSizer *arg1 = (wxSizer *) 0 ;
40327 wxWindow *arg2 = (wxWindow *) 0 ;
40328 PyObject * obj0 = 0 ;
40329 PyObject * obj1 = 0 ;
40330 char *kwnames[] = {
40331 (char *) "self",(char *) "window", NULL
40332 };
40333
40334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40336 if (SWIG_arg_fail(1)) SWIG_fail;
40337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40338 if (SWIG_arg_fail(2)) SWIG_fail;
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 (arg1)->SetSizeHints(arg2);
40342
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 Py_INCREF(Py_None); resultobj = Py_None;
40347 return resultobj;
40348 fail:
40349 return NULL;
40350 }
40351
40352
40353 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40354 PyObject *resultobj;
40355 wxSizer *arg1 = (wxSizer *) 0 ;
40356 wxWindow *arg2 = (wxWindow *) 0 ;
40357 PyObject * obj0 = 0 ;
40358 PyObject * obj1 = 0 ;
40359 char *kwnames[] = {
40360 (char *) "self",(char *) "window", NULL
40361 };
40362
40363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40365 if (SWIG_arg_fail(1)) SWIG_fail;
40366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40367 if (SWIG_arg_fail(2)) SWIG_fail;
40368 {
40369 PyThreadState* __tstate = wxPyBeginAllowThreads();
40370 (arg1)->SetVirtualSizeHints(arg2);
40371
40372 wxPyEndAllowThreads(__tstate);
40373 if (PyErr_Occurred()) SWIG_fail;
40374 }
40375 Py_INCREF(Py_None); resultobj = Py_None;
40376 return resultobj;
40377 fail:
40378 return NULL;
40379 }
40380
40381
40382 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40383 PyObject *resultobj;
40384 wxSizer *arg1 = (wxSizer *) 0 ;
40385 bool arg2 = (bool) false ;
40386 PyObject * obj0 = 0 ;
40387 PyObject * obj1 = 0 ;
40388 char *kwnames[] = {
40389 (char *) "self",(char *) "deleteWindows", NULL
40390 };
40391
40392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40394 if (SWIG_arg_fail(1)) SWIG_fail;
40395 if (obj1) {
40396 {
40397 arg2 = (bool)(SWIG_As_bool(obj1));
40398 if (SWIG_arg_fail(2)) SWIG_fail;
40399 }
40400 }
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->Clear(arg2);
40404
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 Py_INCREF(Py_None); resultobj = Py_None;
40409 return resultobj;
40410 fail:
40411 return NULL;
40412 }
40413
40414
40415 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40416 PyObject *resultobj;
40417 wxSizer *arg1 = (wxSizer *) 0 ;
40418 PyObject * obj0 = 0 ;
40419 char *kwnames[] = {
40420 (char *) "self", NULL
40421 };
40422
40423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40425 if (SWIG_arg_fail(1)) SWIG_fail;
40426 {
40427 PyThreadState* __tstate = wxPyBeginAllowThreads();
40428 (arg1)->DeleteWindows();
40429
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 Py_INCREF(Py_None); resultobj = Py_None;
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj;
40442 wxSizer *arg1 = (wxSizer *) 0 ;
40443 PyObject *result;
40444 PyObject * obj0 = 0 ;
40445 char *kwnames[] = {
40446 (char *) "self", NULL
40447 };
40448
40449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40451 if (SWIG_arg_fail(1)) SWIG_fail;
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 result = (PyObject *)wxSizer_GetChildren(arg1);
40455
40456 wxPyEndAllowThreads(__tstate);
40457 if (PyErr_Occurred()) SWIG_fail;
40458 }
40459 resultobj = result;
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj;
40468 wxSizer *arg1 = (wxSizer *) 0 ;
40469 PyObject *arg2 = (PyObject *) 0 ;
40470 bool arg3 = (bool) true ;
40471 bool arg4 = (bool) false ;
40472 bool result;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 PyObject * obj2 = 0 ;
40476 PyObject * obj3 = 0 ;
40477 char *kwnames[] = {
40478 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40479 };
40480
40481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40483 if (SWIG_arg_fail(1)) SWIG_fail;
40484 arg2 = obj1;
40485 if (obj2) {
40486 {
40487 arg3 = (bool)(SWIG_As_bool(obj2));
40488 if (SWIG_arg_fail(3)) SWIG_fail;
40489 }
40490 }
40491 if (obj3) {
40492 {
40493 arg4 = (bool)(SWIG_As_bool(obj3));
40494 if (SWIG_arg_fail(4)) SWIG_fail;
40495 }
40496 }
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40500
40501 wxPyEndAllowThreads(__tstate);
40502 if (PyErr_Occurred()) SWIG_fail;
40503 }
40504 {
40505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40506 }
40507 return resultobj;
40508 fail:
40509 return NULL;
40510 }
40511
40512
40513 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40514 PyObject *resultobj;
40515 wxSizer *arg1 = (wxSizer *) 0 ;
40516 PyObject *arg2 = (PyObject *) 0 ;
40517 bool result;
40518 PyObject * obj0 = 0 ;
40519 PyObject * obj1 = 0 ;
40520 char *kwnames[] = {
40521 (char *) "self",(char *) "item", NULL
40522 };
40523
40524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40526 if (SWIG_arg_fail(1)) SWIG_fail;
40527 arg2 = obj1;
40528 {
40529 PyThreadState* __tstate = wxPyBeginAllowThreads();
40530 result = (bool)wxSizer_IsShown(arg1,arg2);
40531
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj;
40546 wxSizer *arg1 = (wxSizer *) 0 ;
40547 bool arg2 ;
40548 PyObject * obj0 = 0 ;
40549 PyObject * obj1 = 0 ;
40550 char *kwnames[] = {
40551 (char *) "self",(char *) "show", NULL
40552 };
40553
40554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40556 if (SWIG_arg_fail(1)) SWIG_fail;
40557 {
40558 arg2 = (bool)(SWIG_As_bool(obj1));
40559 if (SWIG_arg_fail(2)) SWIG_fail;
40560 }
40561 {
40562 PyThreadState* __tstate = wxPyBeginAllowThreads();
40563 (arg1)->ShowItems(arg2);
40564
40565 wxPyEndAllowThreads(__tstate);
40566 if (PyErr_Occurred()) SWIG_fail;
40567 }
40568 Py_INCREF(Py_None); resultobj = Py_None;
40569 return resultobj;
40570 fail:
40571 return NULL;
40572 }
40573
40574
40575 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40576 PyObject *obj;
40577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40578 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40579 Py_INCREF(obj);
40580 return Py_BuildValue((char *)"");
40581 }
40582 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40583 PyObject *resultobj;
40584 wxPySizer *result;
40585 char *kwnames[] = {
40586 NULL
40587 };
40588
40589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 result = (wxPySizer *)new wxPySizer();
40593
40594 wxPyEndAllowThreads(__tstate);
40595 if (PyErr_Occurred()) SWIG_fail;
40596 }
40597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40598 return resultobj;
40599 fail:
40600 return NULL;
40601 }
40602
40603
40604 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40605 PyObject *resultobj;
40606 wxPySizer *arg1 = (wxPySizer *) 0 ;
40607 PyObject *arg2 = (PyObject *) 0 ;
40608 PyObject *arg3 = (PyObject *) 0 ;
40609 PyObject * obj0 = 0 ;
40610 PyObject * obj1 = 0 ;
40611 PyObject * obj2 = 0 ;
40612 char *kwnames[] = {
40613 (char *) "self",(char *) "self",(char *) "_class", NULL
40614 };
40615
40616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40618 if (SWIG_arg_fail(1)) SWIG_fail;
40619 arg2 = obj1;
40620 arg3 = obj2;
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 (arg1)->_setCallbackInfo(arg2,arg3);
40624
40625 wxPyEndAllowThreads(__tstate);
40626 if (PyErr_Occurred()) SWIG_fail;
40627 }
40628 Py_INCREF(Py_None); resultobj = Py_None;
40629 return resultobj;
40630 fail:
40631 return NULL;
40632 }
40633
40634
40635 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40636 PyObject *obj;
40637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40638 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40639 Py_INCREF(obj);
40640 return Py_BuildValue((char *)"");
40641 }
40642 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj;
40644 int arg1 = (int) wxHORIZONTAL ;
40645 wxBoxSizer *result;
40646 PyObject * obj0 = 0 ;
40647 char *kwnames[] = {
40648 (char *) "orient", NULL
40649 };
40650
40651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40652 if (obj0) {
40653 {
40654 arg1 = (int)(SWIG_As_int(obj0));
40655 if (SWIG_arg_fail(1)) SWIG_fail;
40656 }
40657 }
40658 {
40659 PyThreadState* __tstate = wxPyBeginAllowThreads();
40660 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40661
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj;
40674 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40675 int result;
40676 PyObject * obj0 = 0 ;
40677 char *kwnames[] = {
40678 (char *) "self", NULL
40679 };
40680
40681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40683 if (SWIG_arg_fail(1)) SWIG_fail;
40684 {
40685 PyThreadState* __tstate = wxPyBeginAllowThreads();
40686 result = (int)(arg1)->GetOrientation();
40687
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 {
40692 resultobj = SWIG_From_int((int)(result));
40693 }
40694 return resultobj;
40695 fail:
40696 return NULL;
40697 }
40698
40699
40700 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40701 PyObject *resultobj;
40702 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40703 int arg2 ;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 char *kwnames[] = {
40707 (char *) "self",(char *) "orient", NULL
40708 };
40709
40710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40712 if (SWIG_arg_fail(1)) SWIG_fail;
40713 {
40714 arg2 = (int)(SWIG_As_int(obj1));
40715 if (SWIG_arg_fail(2)) SWIG_fail;
40716 }
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 (arg1)->SetOrientation(arg2);
40720
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 Py_INCREF(Py_None); resultobj = Py_None;
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40732 PyObject *obj;
40733 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40734 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40735 Py_INCREF(obj);
40736 return Py_BuildValue((char *)"");
40737 }
40738 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj;
40740 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40741 int arg2 = (int) wxHORIZONTAL ;
40742 wxStaticBoxSizer *result;
40743 PyObject * obj0 = 0 ;
40744 PyObject * obj1 = 0 ;
40745 char *kwnames[] = {
40746 (char *) "box",(char *) "orient", NULL
40747 };
40748
40749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40751 if (SWIG_arg_fail(1)) SWIG_fail;
40752 if (obj1) {
40753 {
40754 arg2 = (int)(SWIG_As_int(obj1));
40755 if (SWIG_arg_fail(2)) SWIG_fail;
40756 }
40757 }
40758 {
40759 PyThreadState* __tstate = wxPyBeginAllowThreads();
40760 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40761
40762 wxPyEndAllowThreads(__tstate);
40763 if (PyErr_Occurred()) SWIG_fail;
40764 }
40765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40766 return resultobj;
40767 fail:
40768 return NULL;
40769 }
40770
40771
40772 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40773 PyObject *resultobj;
40774 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40775 wxStaticBox *result;
40776 PyObject * obj0 = 0 ;
40777 char *kwnames[] = {
40778 (char *) "self", NULL
40779 };
40780
40781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40783 if (SWIG_arg_fail(1)) SWIG_fail;
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 result = (wxStaticBox *)(arg1)->GetStaticBox();
40787
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 {
40792 resultobj = wxPyMake_wxObject(result, 0);
40793 }
40794 return resultobj;
40795 fail:
40796 return NULL;
40797 }
40798
40799
40800 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40801 PyObject *obj;
40802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40803 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40804 Py_INCREF(obj);
40805 return Py_BuildValue((char *)"");
40806 }
40807 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40808 PyObject *resultobj;
40809 int arg1 = (int) 1 ;
40810 int arg2 = (int) 0 ;
40811 int arg3 = (int) 0 ;
40812 int arg4 = (int) 0 ;
40813 wxGridSizer *result;
40814 PyObject * obj0 = 0 ;
40815 PyObject * obj1 = 0 ;
40816 PyObject * obj2 = 0 ;
40817 PyObject * obj3 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40823 if (obj0) {
40824 {
40825 arg1 = (int)(SWIG_As_int(obj0));
40826 if (SWIG_arg_fail(1)) SWIG_fail;
40827 }
40828 }
40829 if (obj1) {
40830 {
40831 arg2 = (int)(SWIG_As_int(obj1));
40832 if (SWIG_arg_fail(2)) SWIG_fail;
40833 }
40834 }
40835 if (obj2) {
40836 {
40837 arg3 = (int)(SWIG_As_int(obj2));
40838 if (SWIG_arg_fail(3)) SWIG_fail;
40839 }
40840 }
40841 if (obj3) {
40842 {
40843 arg4 = (int)(SWIG_As_int(obj3));
40844 if (SWIG_arg_fail(4)) SWIG_fail;
40845 }
40846 }
40847 {
40848 PyThreadState* __tstate = wxPyBeginAllowThreads();
40849 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40850
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40855 return resultobj;
40856 fail:
40857 return NULL;
40858 }
40859
40860
40861 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40862 PyObject *resultobj;
40863 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40864 int arg2 ;
40865 PyObject * obj0 = 0 ;
40866 PyObject * obj1 = 0 ;
40867 char *kwnames[] = {
40868 (char *) "self",(char *) "cols", NULL
40869 };
40870
40871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40873 if (SWIG_arg_fail(1)) SWIG_fail;
40874 {
40875 arg2 = (int)(SWIG_As_int(obj1));
40876 if (SWIG_arg_fail(2)) SWIG_fail;
40877 }
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 (arg1)->SetCols(arg2);
40881
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 Py_INCREF(Py_None); resultobj = Py_None;
40886 return resultobj;
40887 fail:
40888 return NULL;
40889 }
40890
40891
40892 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40893 PyObject *resultobj;
40894 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40895 int arg2 ;
40896 PyObject * obj0 = 0 ;
40897 PyObject * obj1 = 0 ;
40898 char *kwnames[] = {
40899 (char *) "self",(char *) "rows", NULL
40900 };
40901
40902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40904 if (SWIG_arg_fail(1)) SWIG_fail;
40905 {
40906 arg2 = (int)(SWIG_As_int(obj1));
40907 if (SWIG_arg_fail(2)) SWIG_fail;
40908 }
40909 {
40910 PyThreadState* __tstate = wxPyBeginAllowThreads();
40911 (arg1)->SetRows(arg2);
40912
40913 wxPyEndAllowThreads(__tstate);
40914 if (PyErr_Occurred()) SWIG_fail;
40915 }
40916 Py_INCREF(Py_None); resultobj = Py_None;
40917 return resultobj;
40918 fail:
40919 return NULL;
40920 }
40921
40922
40923 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40924 PyObject *resultobj;
40925 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40926 int arg2 ;
40927 PyObject * obj0 = 0 ;
40928 PyObject * obj1 = 0 ;
40929 char *kwnames[] = {
40930 (char *) "self",(char *) "gap", NULL
40931 };
40932
40933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40935 if (SWIG_arg_fail(1)) SWIG_fail;
40936 {
40937 arg2 = (int)(SWIG_As_int(obj1));
40938 if (SWIG_arg_fail(2)) SWIG_fail;
40939 }
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 (arg1)->SetVGap(arg2);
40943
40944 wxPyEndAllowThreads(__tstate);
40945 if (PyErr_Occurred()) SWIG_fail;
40946 }
40947 Py_INCREF(Py_None); resultobj = Py_None;
40948 return resultobj;
40949 fail:
40950 return NULL;
40951 }
40952
40953
40954 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40955 PyObject *resultobj;
40956 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40957 int arg2 ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 char *kwnames[] = {
40961 (char *) "self",(char *) "gap", NULL
40962 };
40963
40964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40966 if (SWIG_arg_fail(1)) SWIG_fail;
40967 {
40968 arg2 = (int)(SWIG_As_int(obj1));
40969 if (SWIG_arg_fail(2)) SWIG_fail;
40970 }
40971 {
40972 PyThreadState* __tstate = wxPyBeginAllowThreads();
40973 (arg1)->SetHGap(arg2);
40974
40975 wxPyEndAllowThreads(__tstate);
40976 if (PyErr_Occurred()) SWIG_fail;
40977 }
40978 Py_INCREF(Py_None); resultobj = Py_None;
40979 return resultobj;
40980 fail:
40981 return NULL;
40982 }
40983
40984
40985 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40986 PyObject *resultobj;
40987 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40988 int result;
40989 PyObject * obj0 = 0 ;
40990 char *kwnames[] = {
40991 (char *) "self", NULL
40992 };
40993
40994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40996 if (SWIG_arg_fail(1)) SWIG_fail;
40997 {
40998 PyThreadState* __tstate = wxPyBeginAllowThreads();
40999 result = (int)(arg1)->GetCols();
41000
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 {
41005 resultobj = SWIG_From_int((int)(result));
41006 }
41007 return resultobj;
41008 fail:
41009 return NULL;
41010 }
41011
41012
41013 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41014 PyObject *resultobj;
41015 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41016 int result;
41017 PyObject * obj0 = 0 ;
41018 char *kwnames[] = {
41019 (char *) "self", NULL
41020 };
41021
41022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41024 if (SWIG_arg_fail(1)) SWIG_fail;
41025 {
41026 PyThreadState* __tstate = wxPyBeginAllowThreads();
41027 result = (int)(arg1)->GetRows();
41028
41029 wxPyEndAllowThreads(__tstate);
41030 if (PyErr_Occurred()) SWIG_fail;
41031 }
41032 {
41033 resultobj = SWIG_From_int((int)(result));
41034 }
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj;
41043 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41044 int result;
41045 PyObject * obj0 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (int)(arg1)->GetVGap();
41056
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 {
41061 resultobj = SWIG_From_int((int)(result));
41062 }
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj;
41071 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41072 int result;
41073 PyObject * obj0 = 0 ;
41074 char *kwnames[] = {
41075 (char *) "self", NULL
41076 };
41077
41078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41080 if (SWIG_arg_fail(1)) SWIG_fail;
41081 {
41082 PyThreadState* __tstate = wxPyBeginAllowThreads();
41083 result = (int)(arg1)->GetHGap();
41084
41085 wxPyEndAllowThreads(__tstate);
41086 if (PyErr_Occurred()) SWIG_fail;
41087 }
41088 {
41089 resultobj = SWIG_From_int((int)(result));
41090 }
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41098 PyObject *obj;
41099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41100 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41101 Py_INCREF(obj);
41102 return Py_BuildValue((char *)"");
41103 }
41104 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj;
41106 int arg1 = (int) 1 ;
41107 int arg2 = (int) 0 ;
41108 int arg3 = (int) 0 ;
41109 int arg4 = (int) 0 ;
41110 wxFlexGridSizer *result;
41111 PyObject * obj0 = 0 ;
41112 PyObject * obj1 = 0 ;
41113 PyObject * obj2 = 0 ;
41114 PyObject * obj3 = 0 ;
41115 char *kwnames[] = {
41116 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41117 };
41118
41119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41120 if (obj0) {
41121 {
41122 arg1 = (int)(SWIG_As_int(obj0));
41123 if (SWIG_arg_fail(1)) SWIG_fail;
41124 }
41125 }
41126 if (obj1) {
41127 {
41128 arg2 = (int)(SWIG_As_int(obj1));
41129 if (SWIG_arg_fail(2)) SWIG_fail;
41130 }
41131 }
41132 if (obj2) {
41133 {
41134 arg3 = (int)(SWIG_As_int(obj2));
41135 if (SWIG_arg_fail(3)) SWIG_fail;
41136 }
41137 }
41138 if (obj3) {
41139 {
41140 arg4 = (int)(SWIG_As_int(obj3));
41141 if (SWIG_arg_fail(4)) SWIG_fail;
41142 }
41143 }
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41147
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41152 return resultobj;
41153 fail:
41154 return NULL;
41155 }
41156
41157
41158 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41159 PyObject *resultobj;
41160 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41161 size_t arg2 ;
41162 int arg3 = (int) 0 ;
41163 PyObject * obj0 = 0 ;
41164 PyObject * obj1 = 0 ;
41165 PyObject * obj2 = 0 ;
41166 char *kwnames[] = {
41167 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41168 };
41169
41170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41172 if (SWIG_arg_fail(1)) SWIG_fail;
41173 {
41174 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41175 if (SWIG_arg_fail(2)) SWIG_fail;
41176 }
41177 if (obj2) {
41178 {
41179 arg3 = (int)(SWIG_As_int(obj2));
41180 if (SWIG_arg_fail(3)) SWIG_fail;
41181 }
41182 }
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 (arg1)->AddGrowableRow(arg2,arg3);
41186
41187 wxPyEndAllowThreads(__tstate);
41188 if (PyErr_Occurred()) SWIG_fail;
41189 }
41190 Py_INCREF(Py_None); resultobj = Py_None;
41191 return resultobj;
41192 fail:
41193 return NULL;
41194 }
41195
41196
41197 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj;
41199 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41200 size_t arg2 ;
41201 PyObject * obj0 = 0 ;
41202 PyObject * obj1 = 0 ;
41203 char *kwnames[] = {
41204 (char *) "self",(char *) "idx", NULL
41205 };
41206
41207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41209 if (SWIG_arg_fail(1)) SWIG_fail;
41210 {
41211 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41212 if (SWIG_arg_fail(2)) SWIG_fail;
41213 }
41214 {
41215 PyThreadState* __tstate = wxPyBeginAllowThreads();
41216 (arg1)->RemoveGrowableRow(arg2);
41217
41218 wxPyEndAllowThreads(__tstate);
41219 if (PyErr_Occurred()) SWIG_fail;
41220 }
41221 Py_INCREF(Py_None); resultobj = Py_None;
41222 return resultobj;
41223 fail:
41224 return NULL;
41225 }
41226
41227
41228 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41229 PyObject *resultobj;
41230 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41231 size_t arg2 ;
41232 int arg3 = (int) 0 ;
41233 PyObject * obj0 = 0 ;
41234 PyObject * obj1 = 0 ;
41235 PyObject * obj2 = 0 ;
41236 char *kwnames[] = {
41237 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41238 };
41239
41240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41242 if (SWIG_arg_fail(1)) SWIG_fail;
41243 {
41244 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41245 if (SWIG_arg_fail(2)) SWIG_fail;
41246 }
41247 if (obj2) {
41248 {
41249 arg3 = (int)(SWIG_As_int(obj2));
41250 if (SWIG_arg_fail(3)) SWIG_fail;
41251 }
41252 }
41253 {
41254 PyThreadState* __tstate = wxPyBeginAllowThreads();
41255 (arg1)->AddGrowableCol(arg2,arg3);
41256
41257 wxPyEndAllowThreads(__tstate);
41258 if (PyErr_Occurred()) SWIG_fail;
41259 }
41260 Py_INCREF(Py_None); resultobj = Py_None;
41261 return resultobj;
41262 fail:
41263 return NULL;
41264 }
41265
41266
41267 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41268 PyObject *resultobj;
41269 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41270 size_t arg2 ;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 char *kwnames[] = {
41274 (char *) "self",(char *) "idx", NULL
41275 };
41276
41277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41279 if (SWIG_arg_fail(1)) SWIG_fail;
41280 {
41281 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41282 if (SWIG_arg_fail(2)) SWIG_fail;
41283 }
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 (arg1)->RemoveGrowableCol(arg2);
41287
41288 wxPyEndAllowThreads(__tstate);
41289 if (PyErr_Occurred()) SWIG_fail;
41290 }
41291 Py_INCREF(Py_None); resultobj = Py_None;
41292 return resultobj;
41293 fail:
41294 return NULL;
41295 }
41296
41297
41298 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj;
41300 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41301 int arg2 ;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 char *kwnames[] = {
41305 (char *) "self",(char *) "direction", NULL
41306 };
41307
41308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41310 if (SWIG_arg_fail(1)) SWIG_fail;
41311 {
41312 arg2 = (int)(SWIG_As_int(obj1));
41313 if (SWIG_arg_fail(2)) SWIG_fail;
41314 }
41315 {
41316 PyThreadState* __tstate = wxPyBeginAllowThreads();
41317 (arg1)->SetFlexibleDirection(arg2);
41318
41319 wxPyEndAllowThreads(__tstate);
41320 if (PyErr_Occurred()) SWIG_fail;
41321 }
41322 Py_INCREF(Py_None); resultobj = Py_None;
41323 return resultobj;
41324 fail:
41325 return NULL;
41326 }
41327
41328
41329 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41330 PyObject *resultobj;
41331 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41332 int result;
41333 PyObject * obj0 = 0 ;
41334 char *kwnames[] = {
41335 (char *) "self", NULL
41336 };
41337
41338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41340 if (SWIG_arg_fail(1)) SWIG_fail;
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 result = (int)(arg1)->GetFlexibleDirection();
41344
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 resultobj = SWIG_From_int((int)(result));
41350 }
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj;
41359 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41360 wxFlexSizerGrowMode arg2 ;
41361 PyObject * obj0 = 0 ;
41362 PyObject * obj1 = 0 ;
41363 char *kwnames[] = {
41364 (char *) "self",(char *) "mode", NULL
41365 };
41366
41367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41369 if (SWIG_arg_fail(1)) SWIG_fail;
41370 {
41371 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41372 if (SWIG_arg_fail(2)) SWIG_fail;
41373 }
41374 {
41375 PyThreadState* __tstate = wxPyBeginAllowThreads();
41376 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41377
41378 wxPyEndAllowThreads(__tstate);
41379 if (PyErr_Occurred()) SWIG_fail;
41380 }
41381 Py_INCREF(Py_None); resultobj = Py_None;
41382 return resultobj;
41383 fail:
41384 return NULL;
41385 }
41386
41387
41388 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41389 PyObject *resultobj;
41390 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41391 wxFlexSizerGrowMode result;
41392 PyObject * obj0 = 0 ;
41393 char *kwnames[] = {
41394 (char *) "self", NULL
41395 };
41396
41397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41399 if (SWIG_arg_fail(1)) SWIG_fail;
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41403
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 resultobj = SWIG_From_int((result));
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj;
41416 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41417 wxArrayInt *result;
41418 PyObject * obj0 = 0 ;
41419 char *kwnames[] = {
41420 (char *) "self", NULL
41421 };
41422
41423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41425 if (SWIG_arg_fail(1)) SWIG_fail;
41426 {
41427 PyThreadState* __tstate = wxPyBeginAllowThreads();
41428 {
41429 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41430 result = (wxArrayInt *) &_result_ref;
41431 }
41432
41433 wxPyEndAllowThreads(__tstate);
41434 if (PyErr_Occurred()) SWIG_fail;
41435 }
41436 {
41437 resultobj = PyList_New(0);
41438 size_t idx;
41439 for (idx = 0; idx < result->GetCount(); idx += 1) {
41440 PyObject* val = PyInt_FromLong( result->Item(idx) );
41441 PyList_Append(resultobj, val);
41442 Py_DECREF(val);
41443 }
41444 }
41445 return resultobj;
41446 fail:
41447 return NULL;
41448 }
41449
41450
41451 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41452 PyObject *resultobj;
41453 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41454 wxArrayInt *result;
41455 PyObject * obj0 = 0 ;
41456 char *kwnames[] = {
41457 (char *) "self", NULL
41458 };
41459
41460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41462 if (SWIG_arg_fail(1)) SWIG_fail;
41463 {
41464 PyThreadState* __tstate = wxPyBeginAllowThreads();
41465 {
41466 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41467 result = (wxArrayInt *) &_result_ref;
41468 }
41469
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 resultobj = PyList_New(0);
41475 size_t idx;
41476 for (idx = 0; idx < result->GetCount(); idx += 1) {
41477 PyObject* val = PyInt_FromLong( result->Item(idx) );
41478 PyList_Append(resultobj, val);
41479 Py_DECREF(val);
41480 }
41481 }
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41489 PyObject *obj;
41490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41491 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41492 Py_INCREF(obj);
41493 return Py_BuildValue((char *)"");
41494 }
41495 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41496 PyObject *resultobj;
41497 wxStdDialogButtonSizer *result;
41498 char *kwnames[] = {
41499 NULL
41500 };
41501
41502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41503 {
41504 PyThreadState* __tstate = wxPyBeginAllowThreads();
41505 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41506
41507 wxPyEndAllowThreads(__tstate);
41508 if (PyErr_Occurred()) SWIG_fail;
41509 }
41510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41518 PyObject *resultobj;
41519 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41520 wxButton *arg2 = (wxButton *) 0 ;
41521 PyObject * obj0 = 0 ;
41522 PyObject * obj1 = 0 ;
41523 char *kwnames[] = {
41524 (char *) "self",(char *) "button", NULL
41525 };
41526
41527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41529 if (SWIG_arg_fail(1)) SWIG_fail;
41530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41531 if (SWIG_arg_fail(2)) SWIG_fail;
41532 {
41533 PyThreadState* __tstate = wxPyBeginAllowThreads();
41534 (arg1)->AddButton(arg2);
41535
41536 wxPyEndAllowThreads(__tstate);
41537 if (PyErr_Occurred()) SWIG_fail;
41538 }
41539 Py_INCREF(Py_None); resultobj = Py_None;
41540 return resultobj;
41541 fail:
41542 return NULL;
41543 }
41544
41545
41546 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41547 PyObject *resultobj;
41548 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41549 PyObject * obj0 = 0 ;
41550 char *kwnames[] = {
41551 (char *) "self", NULL
41552 };
41553
41554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41556 if (SWIG_arg_fail(1)) SWIG_fail;
41557 {
41558 PyThreadState* __tstate = wxPyBeginAllowThreads();
41559 (arg1)->Realize();
41560
41561 wxPyEndAllowThreads(__tstate);
41562 if (PyErr_Occurred()) SWIG_fail;
41563 }
41564 Py_INCREF(Py_None); resultobj = Py_None;
41565 return resultobj;
41566 fail:
41567 return NULL;
41568 }
41569
41570
41571 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj;
41573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41574 wxButton *arg2 = (wxButton *) 0 ;
41575 PyObject * obj0 = 0 ;
41576 PyObject * obj1 = 0 ;
41577 char *kwnames[] = {
41578 (char *) "self",(char *) "button", NULL
41579 };
41580
41581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41583 if (SWIG_arg_fail(1)) SWIG_fail;
41584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41585 if (SWIG_arg_fail(2)) SWIG_fail;
41586 {
41587 PyThreadState* __tstate = wxPyBeginAllowThreads();
41588 (arg1)->SetAffirmativeButton(arg2);
41589
41590 wxPyEndAllowThreads(__tstate);
41591 if (PyErr_Occurred()) SWIG_fail;
41592 }
41593 Py_INCREF(Py_None); resultobj = Py_None;
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41601 PyObject *resultobj;
41602 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41603 wxButton *arg2 = (wxButton *) 0 ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char *kwnames[] = {
41607 (char *) "self",(char *) "button", NULL
41608 };
41609
41610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41612 if (SWIG_arg_fail(1)) SWIG_fail;
41613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41614 if (SWIG_arg_fail(2)) SWIG_fail;
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 (arg1)->SetNegativeButton(arg2);
41618
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 Py_INCREF(Py_None); resultobj = Py_None;
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41630 PyObject *resultobj;
41631 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41632 wxButton *arg2 = (wxButton *) 0 ;
41633 PyObject * obj0 = 0 ;
41634 PyObject * obj1 = 0 ;
41635 char *kwnames[] = {
41636 (char *) "self",(char *) "button", NULL
41637 };
41638
41639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41641 if (SWIG_arg_fail(1)) SWIG_fail;
41642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41643 if (SWIG_arg_fail(2)) SWIG_fail;
41644 {
41645 PyThreadState* __tstate = wxPyBeginAllowThreads();
41646 (arg1)->SetCancelButton(arg2);
41647
41648 wxPyEndAllowThreads(__tstate);
41649 if (PyErr_Occurred()) SWIG_fail;
41650 }
41651 Py_INCREF(Py_None); resultobj = Py_None;
41652 return resultobj;
41653 fail:
41654 return NULL;
41655 }
41656
41657
41658 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41659 PyObject *resultobj;
41660 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41661 wxButton *result;
41662 PyObject * obj0 = 0 ;
41663 char *kwnames[] = {
41664 (char *) "self", NULL
41665 };
41666
41667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41669 if (SWIG_arg_fail(1)) SWIG_fail;
41670 {
41671 PyThreadState* __tstate = wxPyBeginAllowThreads();
41672 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41673
41674 wxPyEndAllowThreads(__tstate);
41675 if (PyErr_Occurred()) SWIG_fail;
41676 }
41677 {
41678 resultobj = wxPyMake_wxObject(result, 0);
41679 }
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41687 PyObject *resultobj;
41688 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41689 wxButton *result;
41690 PyObject * obj0 = 0 ;
41691 char *kwnames[] = {
41692 (char *) "self", NULL
41693 };
41694
41695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41697 if (SWIG_arg_fail(1)) SWIG_fail;
41698 {
41699 PyThreadState* __tstate = wxPyBeginAllowThreads();
41700 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41701
41702 wxPyEndAllowThreads(__tstate);
41703 if (PyErr_Occurred()) SWIG_fail;
41704 }
41705 {
41706 resultobj = wxPyMake_wxObject(result, 0);
41707 }
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj;
41716 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41717 wxButton *result;
41718 PyObject * obj0 = 0 ;
41719 char *kwnames[] = {
41720 (char *) "self", NULL
41721 };
41722
41723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41725 if (SWIG_arg_fail(1)) SWIG_fail;
41726 {
41727 PyThreadState* __tstate = wxPyBeginAllowThreads();
41728 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41729
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 {
41734 resultobj = wxPyMake_wxObject(result, 0);
41735 }
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj;
41744 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41745 wxButton *result;
41746 PyObject * obj0 = 0 ;
41747 char *kwnames[] = {
41748 (char *) "self", NULL
41749 };
41750
41751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41753 if (SWIG_arg_fail(1)) SWIG_fail;
41754 {
41755 PyThreadState* __tstate = wxPyBeginAllowThreads();
41756 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41757
41758 wxPyEndAllowThreads(__tstate);
41759 if (PyErr_Occurred()) SWIG_fail;
41760 }
41761 {
41762 resultobj = wxPyMake_wxObject(result, 0);
41763 }
41764 return resultobj;
41765 fail:
41766 return NULL;
41767 }
41768
41769
41770 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41771 PyObject *resultobj;
41772 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41773 wxButton *result;
41774 PyObject * obj0 = 0 ;
41775 char *kwnames[] = {
41776 (char *) "self", NULL
41777 };
41778
41779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41781 if (SWIG_arg_fail(1)) SWIG_fail;
41782 {
41783 PyThreadState* __tstate = wxPyBeginAllowThreads();
41784 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41785
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 {
41790 resultobj = wxPyMake_wxObject(result, 0);
41791 }
41792 return resultobj;
41793 fail:
41794 return NULL;
41795 }
41796
41797
41798 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41799 PyObject *obj;
41800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41801 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41802 Py_INCREF(obj);
41803 return Py_BuildValue((char *)"");
41804 }
41805 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41806 PyObject *resultobj;
41807 int arg1 = (int) 0 ;
41808 int arg2 = (int) 0 ;
41809 wxGBPosition *result;
41810 PyObject * obj0 = 0 ;
41811 PyObject * obj1 = 0 ;
41812 char *kwnames[] = {
41813 (char *) "row",(char *) "col", NULL
41814 };
41815
41816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41817 if (obj0) {
41818 {
41819 arg1 = (int)(SWIG_As_int(obj0));
41820 if (SWIG_arg_fail(1)) SWIG_fail;
41821 }
41822 }
41823 if (obj1) {
41824 {
41825 arg2 = (int)(SWIG_As_int(obj1));
41826 if (SWIG_arg_fail(2)) SWIG_fail;
41827 }
41828 }
41829 {
41830 PyThreadState* __tstate = wxPyBeginAllowThreads();
41831 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41832
41833 wxPyEndAllowThreads(__tstate);
41834 if (PyErr_Occurred()) SWIG_fail;
41835 }
41836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41837 return resultobj;
41838 fail:
41839 return NULL;
41840 }
41841
41842
41843 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41844 PyObject *resultobj;
41845 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41846 int result;
41847 PyObject * obj0 = 0 ;
41848 char *kwnames[] = {
41849 (char *) "self", NULL
41850 };
41851
41852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41854 if (SWIG_arg_fail(1)) SWIG_fail;
41855 {
41856 PyThreadState* __tstate = wxPyBeginAllowThreads();
41857 result = (int)((wxGBPosition const *)arg1)->GetRow();
41858
41859 wxPyEndAllowThreads(__tstate);
41860 if (PyErr_Occurred()) SWIG_fail;
41861 }
41862 {
41863 resultobj = SWIG_From_int((int)(result));
41864 }
41865 return resultobj;
41866 fail:
41867 return NULL;
41868 }
41869
41870
41871 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41872 PyObject *resultobj;
41873 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41874 int result;
41875 PyObject * obj0 = 0 ;
41876 char *kwnames[] = {
41877 (char *) "self", NULL
41878 };
41879
41880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41882 if (SWIG_arg_fail(1)) SWIG_fail;
41883 {
41884 PyThreadState* __tstate = wxPyBeginAllowThreads();
41885 result = (int)((wxGBPosition const *)arg1)->GetCol();
41886
41887 wxPyEndAllowThreads(__tstate);
41888 if (PyErr_Occurred()) SWIG_fail;
41889 }
41890 {
41891 resultobj = SWIG_From_int((int)(result));
41892 }
41893 return resultobj;
41894 fail:
41895 return NULL;
41896 }
41897
41898
41899 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41900 PyObject *resultobj;
41901 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41902 int arg2 ;
41903 PyObject * obj0 = 0 ;
41904 PyObject * obj1 = 0 ;
41905 char *kwnames[] = {
41906 (char *) "self",(char *) "row", NULL
41907 };
41908
41909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",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 = (int)(SWIG_As_int(obj1));
41914 if (SWIG_arg_fail(2)) SWIG_fail;
41915 }
41916 {
41917 PyThreadState* __tstate = wxPyBeginAllowThreads();
41918 (arg1)->SetRow(arg2);
41919
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 Py_INCREF(Py_None); resultobj = Py_None;
41924 return resultobj;
41925 fail:
41926 return NULL;
41927 }
41928
41929
41930 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41931 PyObject *resultobj;
41932 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41933 int arg2 ;
41934 PyObject * obj0 = 0 ;
41935 PyObject * obj1 = 0 ;
41936 char *kwnames[] = {
41937 (char *) "self",(char *) "col", NULL
41938 };
41939
41940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41942 if (SWIG_arg_fail(1)) SWIG_fail;
41943 {
41944 arg2 = (int)(SWIG_As_int(obj1));
41945 if (SWIG_arg_fail(2)) SWIG_fail;
41946 }
41947 {
41948 PyThreadState* __tstate = wxPyBeginAllowThreads();
41949 (arg1)->SetCol(arg2);
41950
41951 wxPyEndAllowThreads(__tstate);
41952 if (PyErr_Occurred()) SWIG_fail;
41953 }
41954 Py_INCREF(Py_None); resultobj = Py_None;
41955 return resultobj;
41956 fail:
41957 return NULL;
41958 }
41959
41960
41961 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41962 PyObject *resultobj;
41963 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41964 wxGBPosition *arg2 = 0 ;
41965 bool result;
41966 wxGBPosition temp2 ;
41967 PyObject * obj0 = 0 ;
41968 PyObject * obj1 = 0 ;
41969 char *kwnames[] = {
41970 (char *) "self",(char *) "other", NULL
41971 };
41972
41973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41975 if (SWIG_arg_fail(1)) SWIG_fail;
41976 {
41977 arg2 = &temp2;
41978 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41983
41984 wxPyEndAllowThreads(__tstate);
41985 if (PyErr_Occurred()) SWIG_fail;
41986 }
41987 {
41988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41989 }
41990 return resultobj;
41991 fail:
41992 return NULL;
41993 }
41994
41995
41996 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41997 PyObject *resultobj;
41998 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41999 wxGBPosition *arg2 = 0 ;
42000 bool result;
42001 wxGBPosition temp2 ;
42002 PyObject * obj0 = 0 ;
42003 PyObject * obj1 = 0 ;
42004 char *kwnames[] = {
42005 (char *) "self",(char *) "other", NULL
42006 };
42007
42008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42010 if (SWIG_arg_fail(1)) SWIG_fail;
42011 {
42012 arg2 = &temp2;
42013 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42014 }
42015 {
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42018
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 {
42023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42024 }
42025 return resultobj;
42026 fail:
42027 return NULL;
42028 }
42029
42030
42031 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42032 PyObject *resultobj;
42033 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42034 int arg2 = (int) 0 ;
42035 int arg3 = (int) 0 ;
42036 PyObject * obj0 = 0 ;
42037 PyObject * obj1 = 0 ;
42038 PyObject * obj2 = 0 ;
42039 char *kwnames[] = {
42040 (char *) "self",(char *) "row",(char *) "col", NULL
42041 };
42042
42043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42045 if (SWIG_arg_fail(1)) SWIG_fail;
42046 if (obj1) {
42047 {
42048 arg2 = (int)(SWIG_As_int(obj1));
42049 if (SWIG_arg_fail(2)) SWIG_fail;
42050 }
42051 }
42052 if (obj2) {
42053 {
42054 arg3 = (int)(SWIG_As_int(obj2));
42055 if (SWIG_arg_fail(3)) SWIG_fail;
42056 }
42057 }
42058 {
42059 PyThreadState* __tstate = wxPyBeginAllowThreads();
42060 wxGBPosition_Set(arg1,arg2,arg3);
42061
42062 wxPyEndAllowThreads(__tstate);
42063 if (PyErr_Occurred()) SWIG_fail;
42064 }
42065 Py_INCREF(Py_None); resultobj = Py_None;
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42073 PyObject *resultobj;
42074 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42075 PyObject *result;
42076 PyObject * obj0 = 0 ;
42077 char *kwnames[] = {
42078 (char *) "self", NULL
42079 };
42080
42081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42083 if (SWIG_arg_fail(1)) SWIG_fail;
42084 {
42085 PyThreadState* __tstate = wxPyBeginAllowThreads();
42086 result = (PyObject *)wxGBPosition_Get(arg1);
42087
42088 wxPyEndAllowThreads(__tstate);
42089 if (PyErr_Occurred()) SWIG_fail;
42090 }
42091 resultobj = result;
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42099 PyObject *obj;
42100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42101 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42102 Py_INCREF(obj);
42103 return Py_BuildValue((char *)"");
42104 }
42105 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj;
42107 int arg1 = (int) 1 ;
42108 int arg2 = (int) 1 ;
42109 wxGBSpan *result;
42110 PyObject * obj0 = 0 ;
42111 PyObject * obj1 = 0 ;
42112 char *kwnames[] = {
42113 (char *) "rowspan",(char *) "colspan", NULL
42114 };
42115
42116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42117 if (obj0) {
42118 {
42119 arg1 = (int)(SWIG_As_int(obj0));
42120 if (SWIG_arg_fail(1)) SWIG_fail;
42121 }
42122 }
42123 if (obj1) {
42124 {
42125 arg2 = (int)(SWIG_As_int(obj1));
42126 if (SWIG_arg_fail(2)) SWIG_fail;
42127 }
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42132
42133 wxPyEndAllowThreads(__tstate);
42134 if (PyErr_Occurred()) SWIG_fail;
42135 }
42136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42137 return resultobj;
42138 fail:
42139 return NULL;
42140 }
42141
42142
42143 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42144 PyObject *resultobj;
42145 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42146 int result;
42147 PyObject * obj0 = 0 ;
42148 char *kwnames[] = {
42149 (char *) "self", NULL
42150 };
42151
42152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42154 if (SWIG_arg_fail(1)) SWIG_fail;
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42158
42159 wxPyEndAllowThreads(__tstate);
42160 if (PyErr_Occurred()) SWIG_fail;
42161 }
42162 {
42163 resultobj = SWIG_From_int((int)(result));
42164 }
42165 return resultobj;
42166 fail:
42167 return NULL;
42168 }
42169
42170
42171 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42172 PyObject *resultobj;
42173 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42174 int result;
42175 PyObject * obj0 = 0 ;
42176 char *kwnames[] = {
42177 (char *) "self", NULL
42178 };
42179
42180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42182 if (SWIG_arg_fail(1)) SWIG_fail;
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42186
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 {
42191 resultobj = SWIG_From_int((int)(result));
42192 }
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42200 PyObject *resultobj;
42201 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42202 int arg2 ;
42203 PyObject * obj0 = 0 ;
42204 PyObject * obj1 = 0 ;
42205 char *kwnames[] = {
42206 (char *) "self",(char *) "rowspan", NULL
42207 };
42208
42209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",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 = (int)(SWIG_As_int(obj1));
42214 if (SWIG_arg_fail(2)) SWIG_fail;
42215 }
42216 {
42217 PyThreadState* __tstate = wxPyBeginAllowThreads();
42218 (arg1)->SetRowspan(arg2);
42219
42220 wxPyEndAllowThreads(__tstate);
42221 if (PyErr_Occurred()) SWIG_fail;
42222 }
42223 Py_INCREF(Py_None); resultobj = Py_None;
42224 return resultobj;
42225 fail:
42226 return NULL;
42227 }
42228
42229
42230 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42231 PyObject *resultobj;
42232 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42233 int arg2 ;
42234 PyObject * obj0 = 0 ;
42235 PyObject * obj1 = 0 ;
42236 char *kwnames[] = {
42237 (char *) "self",(char *) "colspan", NULL
42238 };
42239
42240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42242 if (SWIG_arg_fail(1)) SWIG_fail;
42243 {
42244 arg2 = (int)(SWIG_As_int(obj1));
42245 if (SWIG_arg_fail(2)) SWIG_fail;
42246 }
42247 {
42248 PyThreadState* __tstate = wxPyBeginAllowThreads();
42249 (arg1)->SetColspan(arg2);
42250
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 Py_INCREF(Py_None); resultobj = Py_None;
42255 return resultobj;
42256 fail:
42257 return NULL;
42258 }
42259
42260
42261 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42262 PyObject *resultobj;
42263 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42264 wxGBSpan *arg2 = 0 ;
42265 bool result;
42266 wxGBSpan temp2 ;
42267 PyObject * obj0 = 0 ;
42268 PyObject * obj1 = 0 ;
42269 char *kwnames[] = {
42270 (char *) "self",(char *) "other", NULL
42271 };
42272
42273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42275 if (SWIG_arg_fail(1)) SWIG_fail;
42276 {
42277 arg2 = &temp2;
42278 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42279 }
42280 {
42281 PyThreadState* __tstate = wxPyBeginAllowThreads();
42282 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42283
42284 wxPyEndAllowThreads(__tstate);
42285 if (PyErr_Occurred()) SWIG_fail;
42286 }
42287 {
42288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42289 }
42290 return resultobj;
42291 fail:
42292 return NULL;
42293 }
42294
42295
42296 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42297 PyObject *resultobj;
42298 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42299 wxGBSpan *arg2 = 0 ;
42300 bool result;
42301 wxGBSpan temp2 ;
42302 PyObject * obj0 = 0 ;
42303 PyObject * obj1 = 0 ;
42304 char *kwnames[] = {
42305 (char *) "self",(char *) "other", NULL
42306 };
42307
42308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42310 if (SWIG_arg_fail(1)) SWIG_fail;
42311 {
42312 arg2 = &temp2;
42313 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42314 }
42315 {
42316 PyThreadState* __tstate = wxPyBeginAllowThreads();
42317 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42318
42319 wxPyEndAllowThreads(__tstate);
42320 if (PyErr_Occurred()) SWIG_fail;
42321 }
42322 {
42323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42324 }
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj;
42333 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42334 int arg2 = (int) 1 ;
42335 int arg3 = (int) 1 ;
42336 PyObject * obj0 = 0 ;
42337 PyObject * obj1 = 0 ;
42338 PyObject * obj2 = 0 ;
42339 char *kwnames[] = {
42340 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42341 };
42342
42343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42345 if (SWIG_arg_fail(1)) SWIG_fail;
42346 if (obj1) {
42347 {
42348 arg2 = (int)(SWIG_As_int(obj1));
42349 if (SWIG_arg_fail(2)) SWIG_fail;
42350 }
42351 }
42352 if (obj2) {
42353 {
42354 arg3 = (int)(SWIG_As_int(obj2));
42355 if (SWIG_arg_fail(3)) SWIG_fail;
42356 }
42357 }
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 wxGBSpan_Set(arg1,arg2,arg3);
42361
42362 wxPyEndAllowThreads(__tstate);
42363 if (PyErr_Occurred()) SWIG_fail;
42364 }
42365 Py_INCREF(Py_None); resultobj = Py_None;
42366 return resultobj;
42367 fail:
42368 return NULL;
42369 }
42370
42371
42372 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42373 PyObject *resultobj;
42374 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42375 PyObject *result;
42376 PyObject * obj0 = 0 ;
42377 char *kwnames[] = {
42378 (char *) "self", NULL
42379 };
42380
42381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42383 if (SWIG_arg_fail(1)) SWIG_fail;
42384 {
42385 PyThreadState* __tstate = wxPyBeginAllowThreads();
42386 result = (PyObject *)wxGBSpan_Get(arg1);
42387
42388 wxPyEndAllowThreads(__tstate);
42389 if (PyErr_Occurred()) SWIG_fail;
42390 }
42391 resultobj = result;
42392 return resultobj;
42393 fail:
42394 return NULL;
42395 }
42396
42397
42398 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42399 PyObject *obj;
42400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42401 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42402 Py_INCREF(obj);
42403 return Py_BuildValue((char *)"");
42404 }
42405 static int _wrap_DefaultSpan_set(PyObject *) {
42406 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42407 return 1;
42408 }
42409
42410
42411 static PyObject *_wrap_DefaultSpan_get(void) {
42412 PyObject *pyobj;
42413
42414 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42415 return pyobj;
42416 }
42417
42418
42419 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42420 PyObject *resultobj;
42421 wxGBSizerItem *result;
42422 char *kwnames[] = {
42423 NULL
42424 };
42425
42426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 result = (wxGBSizerItem *)new wxGBSizerItem();
42430
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42435 return resultobj;
42436 fail:
42437 return NULL;
42438 }
42439
42440
42441 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42442 PyObject *resultobj;
42443 wxWindow *arg1 = (wxWindow *) 0 ;
42444 wxGBPosition *arg2 = 0 ;
42445 wxGBSpan *arg3 = 0 ;
42446 int arg4 ;
42447 int arg5 ;
42448 PyObject *arg6 = (PyObject *) NULL ;
42449 wxGBSizerItem *result;
42450 wxGBPosition temp2 ;
42451 wxGBSpan temp3 ;
42452 PyObject * obj0 = 0 ;
42453 PyObject * obj1 = 0 ;
42454 PyObject * obj2 = 0 ;
42455 PyObject * obj3 = 0 ;
42456 PyObject * obj4 = 0 ;
42457 PyObject * obj5 = 0 ;
42458 char *kwnames[] = {
42459 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42460 };
42461
42462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42464 if (SWIG_arg_fail(1)) SWIG_fail;
42465 {
42466 arg2 = &temp2;
42467 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42468 }
42469 {
42470 arg3 = &temp3;
42471 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42472 }
42473 {
42474 arg4 = (int)(SWIG_As_int(obj3));
42475 if (SWIG_arg_fail(4)) SWIG_fail;
42476 }
42477 {
42478 arg5 = (int)(SWIG_As_int(obj4));
42479 if (SWIG_arg_fail(5)) SWIG_fail;
42480 }
42481 if (obj5) {
42482 arg6 = obj5;
42483 }
42484 {
42485 PyThreadState* __tstate = wxPyBeginAllowThreads();
42486 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42487
42488 wxPyEndAllowThreads(__tstate);
42489 if (PyErr_Occurred()) SWIG_fail;
42490 }
42491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42492 return resultobj;
42493 fail:
42494 return NULL;
42495 }
42496
42497
42498 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42499 PyObject *resultobj;
42500 wxSizer *arg1 = (wxSizer *) 0 ;
42501 wxGBPosition *arg2 = 0 ;
42502 wxGBSpan *arg3 = 0 ;
42503 int arg4 ;
42504 int arg5 ;
42505 PyObject *arg6 = (PyObject *) NULL ;
42506 wxGBSizerItem *result;
42507 wxGBPosition temp2 ;
42508 wxGBSpan temp3 ;
42509 PyObject * obj0 = 0 ;
42510 PyObject * obj1 = 0 ;
42511 PyObject * obj2 = 0 ;
42512 PyObject * obj3 = 0 ;
42513 PyObject * obj4 = 0 ;
42514 PyObject * obj5 = 0 ;
42515 char *kwnames[] = {
42516 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42517 };
42518
42519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42521 if (SWIG_arg_fail(1)) SWIG_fail;
42522 {
42523 arg2 = &temp2;
42524 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42525 }
42526 {
42527 arg3 = &temp3;
42528 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42529 }
42530 {
42531 arg4 = (int)(SWIG_As_int(obj3));
42532 if (SWIG_arg_fail(4)) SWIG_fail;
42533 }
42534 {
42535 arg5 = (int)(SWIG_As_int(obj4));
42536 if (SWIG_arg_fail(5)) SWIG_fail;
42537 }
42538 if (obj5) {
42539 arg6 = obj5;
42540 }
42541 {
42542 PyThreadState* __tstate = wxPyBeginAllowThreads();
42543 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42544
42545 wxPyEndAllowThreads(__tstate);
42546 if (PyErr_Occurred()) SWIG_fail;
42547 }
42548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42549 return resultobj;
42550 fail:
42551 return NULL;
42552 }
42553
42554
42555 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42556 PyObject *resultobj;
42557 int arg1 ;
42558 int arg2 ;
42559 wxGBPosition *arg3 = 0 ;
42560 wxGBSpan *arg4 = 0 ;
42561 int arg5 ;
42562 int arg6 ;
42563 PyObject *arg7 = (PyObject *) NULL ;
42564 wxGBSizerItem *result;
42565 wxGBPosition temp3 ;
42566 wxGBSpan temp4 ;
42567 PyObject * obj0 = 0 ;
42568 PyObject * obj1 = 0 ;
42569 PyObject * obj2 = 0 ;
42570 PyObject * obj3 = 0 ;
42571 PyObject * obj4 = 0 ;
42572 PyObject * obj5 = 0 ;
42573 PyObject * obj6 = 0 ;
42574 char *kwnames[] = {
42575 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42576 };
42577
42578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42579 {
42580 arg1 = (int)(SWIG_As_int(obj0));
42581 if (SWIG_arg_fail(1)) SWIG_fail;
42582 }
42583 {
42584 arg2 = (int)(SWIG_As_int(obj1));
42585 if (SWIG_arg_fail(2)) SWIG_fail;
42586 }
42587 {
42588 arg3 = &temp3;
42589 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42590 }
42591 {
42592 arg4 = &temp4;
42593 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42594 }
42595 {
42596 arg5 = (int)(SWIG_As_int(obj4));
42597 if (SWIG_arg_fail(5)) SWIG_fail;
42598 }
42599 {
42600 arg6 = (int)(SWIG_As_int(obj5));
42601 if (SWIG_arg_fail(6)) SWIG_fail;
42602 }
42603 if (obj6) {
42604 arg7 = obj6;
42605 }
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42609
42610 wxPyEndAllowThreads(__tstate);
42611 if (PyErr_Occurred()) SWIG_fail;
42612 }
42613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42614 return resultobj;
42615 fail:
42616 return NULL;
42617 }
42618
42619
42620 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42621 PyObject *resultobj;
42622 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42623 wxGBPosition result;
42624 PyObject * obj0 = 0 ;
42625 char *kwnames[] = {
42626 (char *) "self", NULL
42627 };
42628
42629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42631 if (SWIG_arg_fail(1)) SWIG_fail;
42632 {
42633 PyThreadState* __tstate = wxPyBeginAllowThreads();
42634 result = ((wxGBSizerItem const *)arg1)->GetPos();
42635
42636 wxPyEndAllowThreads(__tstate);
42637 if (PyErr_Occurred()) SWIG_fail;
42638 }
42639 {
42640 wxGBPosition * resultptr;
42641 resultptr = new wxGBPosition((wxGBPosition &)(result));
42642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42643 }
42644 return resultobj;
42645 fail:
42646 return NULL;
42647 }
42648
42649
42650 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42651 PyObject *resultobj;
42652 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42653 wxGBSpan result;
42654 PyObject * obj0 = 0 ;
42655 char *kwnames[] = {
42656 (char *) "self", NULL
42657 };
42658
42659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42661 if (SWIG_arg_fail(1)) SWIG_fail;
42662 {
42663 PyThreadState* __tstate = wxPyBeginAllowThreads();
42664 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42665
42666 wxPyEndAllowThreads(__tstate);
42667 if (PyErr_Occurred()) SWIG_fail;
42668 }
42669 {
42670 wxGBSpan * resultptr;
42671 resultptr = new wxGBSpan((wxGBSpan &)(result));
42672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42673 }
42674 return resultobj;
42675 fail:
42676 return NULL;
42677 }
42678
42679
42680 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42681 PyObject *resultobj;
42682 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42683 wxGBPosition *arg2 = 0 ;
42684 bool result;
42685 wxGBPosition temp2 ;
42686 PyObject * obj0 = 0 ;
42687 PyObject * obj1 = 0 ;
42688 char *kwnames[] = {
42689 (char *) "self",(char *) "pos", NULL
42690 };
42691
42692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42694 if (SWIG_arg_fail(1)) SWIG_fail;
42695 {
42696 arg2 = &temp2;
42697 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42698 }
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42702
42703 wxPyEndAllowThreads(__tstate);
42704 if (PyErr_Occurred()) SWIG_fail;
42705 }
42706 {
42707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42708 }
42709 return resultobj;
42710 fail:
42711 return NULL;
42712 }
42713
42714
42715 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42716 PyObject *resultobj;
42717 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42718 wxGBSpan *arg2 = 0 ;
42719 bool result;
42720 wxGBSpan temp2 ;
42721 PyObject * obj0 = 0 ;
42722 PyObject * obj1 = 0 ;
42723 char *kwnames[] = {
42724 (char *) "self",(char *) "span", NULL
42725 };
42726
42727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42729 if (SWIG_arg_fail(1)) SWIG_fail;
42730 {
42731 arg2 = &temp2;
42732 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42733 }
42734 {
42735 PyThreadState* __tstate = wxPyBeginAllowThreads();
42736 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42737
42738 wxPyEndAllowThreads(__tstate);
42739 if (PyErr_Occurred()) SWIG_fail;
42740 }
42741 {
42742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42743 }
42744 return resultobj;
42745 fail:
42746 return NULL;
42747 }
42748
42749
42750 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42751 PyObject *resultobj;
42752 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42753 wxGBSizerItem *arg2 = 0 ;
42754 bool result;
42755 PyObject * obj0 = 0 ;
42756 PyObject * obj1 = 0 ;
42757 char *kwnames[] = {
42758 (char *) "self",(char *) "other", NULL
42759 };
42760
42761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42763 if (SWIG_arg_fail(1)) SWIG_fail;
42764 {
42765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42766 if (SWIG_arg_fail(2)) SWIG_fail;
42767 if (arg2 == NULL) {
42768 SWIG_null_ref("wxGBSizerItem");
42769 }
42770 if (SWIG_arg_fail(2)) SWIG_fail;
42771 }
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42775
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 {
42780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42781 }
42782 return resultobj;
42783 fail:
42784 return NULL;
42785 }
42786
42787
42788 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42789 PyObject *resultobj;
42790 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42791 wxGBPosition *arg2 = 0 ;
42792 wxGBSpan *arg3 = 0 ;
42793 bool result;
42794 wxGBPosition temp2 ;
42795 wxGBSpan temp3 ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 PyObject * obj2 = 0 ;
42799 char *kwnames[] = {
42800 (char *) "self",(char *) "pos",(char *) "span", NULL
42801 };
42802
42803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42805 if (SWIG_arg_fail(1)) SWIG_fail;
42806 {
42807 arg2 = &temp2;
42808 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42809 }
42810 {
42811 arg3 = &temp3;
42812 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42813 }
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42817
42818 wxPyEndAllowThreads(__tstate);
42819 if (PyErr_Occurred()) SWIG_fail;
42820 }
42821 {
42822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42823 }
42824 return resultobj;
42825 fail:
42826 return NULL;
42827 }
42828
42829
42830 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42831 PyObject *resultobj;
42832 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42833 wxGBPosition result;
42834 PyObject * obj0 = 0 ;
42835 char *kwnames[] = {
42836 (char *) "self", NULL
42837 };
42838
42839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42841 if (SWIG_arg_fail(1)) SWIG_fail;
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 result = wxGBSizerItem_GetEndPos(arg1);
42845
42846 wxPyEndAllowThreads(__tstate);
42847 if (PyErr_Occurred()) SWIG_fail;
42848 }
42849 {
42850 wxGBPosition * resultptr;
42851 resultptr = new wxGBPosition((wxGBPosition &)(result));
42852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42853 }
42854 return resultobj;
42855 fail:
42856 return NULL;
42857 }
42858
42859
42860 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42861 PyObject *resultobj;
42862 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42863 wxGridBagSizer *result;
42864 PyObject * obj0 = 0 ;
42865 char *kwnames[] = {
42866 (char *) "self", NULL
42867 };
42868
42869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42871 if (SWIG_arg_fail(1)) SWIG_fail;
42872 {
42873 PyThreadState* __tstate = wxPyBeginAllowThreads();
42874 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42875
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42880 return resultobj;
42881 fail:
42882 return NULL;
42883 }
42884
42885
42886 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42887 PyObject *resultobj;
42888 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42889 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42890 PyObject * obj0 = 0 ;
42891 PyObject * obj1 = 0 ;
42892 char *kwnames[] = {
42893 (char *) "self",(char *) "sizer", NULL
42894 };
42895
42896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42898 if (SWIG_arg_fail(1)) SWIG_fail;
42899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42900 if (SWIG_arg_fail(2)) SWIG_fail;
42901 {
42902 PyThreadState* __tstate = wxPyBeginAllowThreads();
42903 (arg1)->SetGBSizer(arg2);
42904
42905 wxPyEndAllowThreads(__tstate);
42906 if (PyErr_Occurred()) SWIG_fail;
42907 }
42908 Py_INCREF(Py_None); resultobj = Py_None;
42909 return resultobj;
42910 fail:
42911 return NULL;
42912 }
42913
42914
42915 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42916 PyObject *obj;
42917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42918 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42919 Py_INCREF(obj);
42920 return Py_BuildValue((char *)"");
42921 }
42922 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42923 PyObject *resultobj;
42924 int arg1 = (int) 0 ;
42925 int arg2 = (int) 0 ;
42926 wxGridBagSizer *result;
42927 PyObject * obj0 = 0 ;
42928 PyObject * obj1 = 0 ;
42929 char *kwnames[] = {
42930 (char *) "vgap",(char *) "hgap", NULL
42931 };
42932
42933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42934 if (obj0) {
42935 {
42936 arg1 = (int)(SWIG_As_int(obj0));
42937 if (SWIG_arg_fail(1)) SWIG_fail;
42938 }
42939 }
42940 if (obj1) {
42941 {
42942 arg2 = (int)(SWIG_As_int(obj1));
42943 if (SWIG_arg_fail(2)) SWIG_fail;
42944 }
42945 }
42946 {
42947 PyThreadState* __tstate = wxPyBeginAllowThreads();
42948 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42949
42950 wxPyEndAllowThreads(__tstate);
42951 if (PyErr_Occurred()) SWIG_fail;
42952 }
42953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42954 return resultobj;
42955 fail:
42956 return NULL;
42957 }
42958
42959
42960 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42961 PyObject *resultobj;
42962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42963 PyObject *arg2 = (PyObject *) 0 ;
42964 wxGBPosition *arg3 = 0 ;
42965 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42966 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42967 int arg5 = (int) 0 ;
42968 int arg6 = (int) 0 ;
42969 PyObject *arg7 = (PyObject *) NULL ;
42970 wxGBSizerItem *result;
42971 wxGBPosition temp3 ;
42972 wxGBSpan temp4 ;
42973 PyObject * obj0 = 0 ;
42974 PyObject * obj1 = 0 ;
42975 PyObject * obj2 = 0 ;
42976 PyObject * obj3 = 0 ;
42977 PyObject * obj4 = 0 ;
42978 PyObject * obj5 = 0 ;
42979 PyObject * obj6 = 0 ;
42980 char *kwnames[] = {
42981 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42982 };
42983
42984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42986 if (SWIG_arg_fail(1)) SWIG_fail;
42987 arg2 = obj1;
42988 {
42989 arg3 = &temp3;
42990 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42991 }
42992 if (obj3) {
42993 {
42994 arg4 = &temp4;
42995 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42996 }
42997 }
42998 if (obj4) {
42999 {
43000 arg5 = (int)(SWIG_As_int(obj4));
43001 if (SWIG_arg_fail(5)) SWIG_fail;
43002 }
43003 }
43004 if (obj5) {
43005 {
43006 arg6 = (int)(SWIG_As_int(obj5));
43007 if (SWIG_arg_fail(6)) SWIG_fail;
43008 }
43009 }
43010 if (obj6) {
43011 arg7 = obj6;
43012 }
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43016
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43021 return resultobj;
43022 fail:
43023 return NULL;
43024 }
43025
43026
43027 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43028 PyObject *resultobj;
43029 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43030 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43031 wxGBSizerItem *result;
43032 PyObject * obj0 = 0 ;
43033 PyObject * obj1 = 0 ;
43034 char *kwnames[] = {
43035 (char *) "self",(char *) "item", NULL
43036 };
43037
43038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43040 if (SWIG_arg_fail(1)) SWIG_fail;
43041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43042 if (SWIG_arg_fail(2)) SWIG_fail;
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43046
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj;
43059 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43060 int arg2 ;
43061 int arg3 ;
43062 wxSize result;
43063 PyObject * obj0 = 0 ;
43064 PyObject * obj1 = 0 ;
43065 PyObject * obj2 = 0 ;
43066 char *kwnames[] = {
43067 (char *) "self",(char *) "row",(char *) "col", NULL
43068 };
43069
43070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43072 if (SWIG_arg_fail(1)) SWIG_fail;
43073 {
43074 arg2 = (int)(SWIG_As_int(obj1));
43075 if (SWIG_arg_fail(2)) SWIG_fail;
43076 }
43077 {
43078 arg3 = (int)(SWIG_As_int(obj2));
43079 if (SWIG_arg_fail(3)) SWIG_fail;
43080 }
43081 {
43082 PyThreadState* __tstate = wxPyBeginAllowThreads();
43083 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43084
43085 wxPyEndAllowThreads(__tstate);
43086 if (PyErr_Occurred()) SWIG_fail;
43087 }
43088 {
43089 wxSize * resultptr;
43090 resultptr = new wxSize((wxSize &)(result));
43091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43092 }
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj;
43101 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43102 wxSize result;
43103 PyObject * obj0 = 0 ;
43104 char *kwnames[] = {
43105 (char *) "self", NULL
43106 };
43107
43108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43110 if (SWIG_arg_fail(1)) SWIG_fail;
43111 {
43112 PyThreadState* __tstate = wxPyBeginAllowThreads();
43113 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43114
43115 wxPyEndAllowThreads(__tstate);
43116 if (PyErr_Occurred()) SWIG_fail;
43117 }
43118 {
43119 wxSize * resultptr;
43120 resultptr = new wxSize((wxSize &)(result));
43121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43122 }
43123 return resultobj;
43124 fail:
43125 return NULL;
43126 }
43127
43128
43129 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43130 PyObject *resultobj;
43131 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43132 wxSize *arg2 = 0 ;
43133 wxSize temp2 ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 char *kwnames[] = {
43137 (char *) "self",(char *) "sz", NULL
43138 };
43139
43140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43142 if (SWIG_arg_fail(1)) SWIG_fail;
43143 {
43144 arg2 = &temp2;
43145 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43146 }
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 Py_INCREF(Py_None); resultobj = Py_None;
43155 return resultobj;
43156 fail:
43157 return NULL;
43158 }
43159
43160
43161 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43162 PyObject *resultobj;
43163 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43164 wxWindow *arg2 = (wxWindow *) 0 ;
43165 wxGBPosition result;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168
43169 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43171 if (SWIG_arg_fail(1)) SWIG_fail;
43172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43173 if (SWIG_arg_fail(2)) SWIG_fail;
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__SWIG_1(PyObject *, PyObject *args) {
43193 PyObject *resultobj;
43194 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43195 wxSizer *arg2 = (wxSizer *) 0 ;
43196 wxGBPosition result;
43197 PyObject * obj0 = 0 ;
43198 PyObject * obj1 = 0 ;
43199
43200 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43202 if (SWIG_arg_fail(1)) SWIG_fail;
43203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43204 if (SWIG_arg_fail(2)) SWIG_fail;
43205 {
43206 PyThreadState* __tstate = wxPyBeginAllowThreads();
43207 result = (arg1)->GetItemPosition(arg2);
43208
43209 wxPyEndAllowThreads(__tstate);
43210 if (PyErr_Occurred()) SWIG_fail;
43211 }
43212 {
43213 wxGBPosition * resultptr;
43214 resultptr = new wxGBPosition((wxGBPosition &)(result));
43215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43216 }
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43224 PyObject *resultobj;
43225 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43226 size_t arg2 ;
43227 wxGBPosition result;
43228 PyObject * obj0 = 0 ;
43229 PyObject * obj1 = 0 ;
43230
43231 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43233 if (SWIG_arg_fail(1)) SWIG_fail;
43234 {
43235 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43236 if (SWIG_arg_fail(2)) SWIG_fail;
43237 }
43238 {
43239 PyThreadState* __tstate = wxPyBeginAllowThreads();
43240 result = (arg1)->GetItemPosition(arg2);
43241
43242 wxPyEndAllowThreads(__tstate);
43243 if (PyErr_Occurred()) SWIG_fail;
43244 }
43245 {
43246 wxGBPosition * resultptr;
43247 resultptr = new wxGBPosition((wxGBPosition &)(result));
43248 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43249 }
43250 return resultobj;
43251 fail:
43252 return NULL;
43253 }
43254
43255
43256 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43257 int argc;
43258 PyObject *argv[3];
43259 int ii;
43260
43261 argc = PyObject_Length(args);
43262 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43263 argv[ii] = PyTuple_GetItem(args,ii);
43264 }
43265 if (argc == 2) {
43266 int _v;
43267 {
43268 void *ptr;
43269 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43270 _v = 0;
43271 PyErr_Clear();
43272 } else {
43273 _v = 1;
43274 }
43275 }
43276 if (_v) {
43277 {
43278 void *ptr;
43279 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43280 _v = 0;
43281 PyErr_Clear();
43282 } else {
43283 _v = 1;
43284 }
43285 }
43286 if (_v) {
43287 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43288 }
43289 }
43290 }
43291 if (argc == 2) {
43292 int _v;
43293 {
43294 void *ptr;
43295 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43296 _v = 0;
43297 PyErr_Clear();
43298 } else {
43299 _v = 1;
43300 }
43301 }
43302 if (_v) {
43303 {
43304 void *ptr;
43305 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43306 _v = 0;
43307 PyErr_Clear();
43308 } else {
43309 _v = 1;
43310 }
43311 }
43312 if (_v) {
43313 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43314 }
43315 }
43316 }
43317 if (argc == 2) {
43318 int _v;
43319 {
43320 void *ptr;
43321 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43322 _v = 0;
43323 PyErr_Clear();
43324 } else {
43325 _v = 1;
43326 }
43327 }
43328 if (_v) {
43329 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43330 if (_v) {
43331 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43332 }
43333 }
43334 }
43335
43336 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43337 return NULL;
43338 }
43339
43340
43341 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43342 PyObject *resultobj;
43343 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43344 wxWindow *arg2 = (wxWindow *) 0 ;
43345 wxGBPosition *arg3 = 0 ;
43346 bool result;
43347 wxGBPosition temp3 ;
43348 PyObject * obj0 = 0 ;
43349 PyObject * obj1 = 0 ;
43350 PyObject * obj2 = 0 ;
43351
43352 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43354 if (SWIG_arg_fail(1)) SWIG_fail;
43355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43356 if (SWIG_arg_fail(2)) SWIG_fail;
43357 {
43358 arg3 = &temp3;
43359 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43360 }
43361 {
43362 PyThreadState* __tstate = wxPyBeginAllowThreads();
43363 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43364
43365 wxPyEndAllowThreads(__tstate);
43366 if (PyErr_Occurred()) SWIG_fail;
43367 }
43368 {
43369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43370 }
43371 return resultobj;
43372 fail:
43373 return NULL;
43374 }
43375
43376
43377 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43378 PyObject *resultobj;
43379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43380 wxSizer *arg2 = (wxSizer *) 0 ;
43381 wxGBPosition *arg3 = 0 ;
43382 bool result;
43383 wxGBPosition temp3 ;
43384 PyObject * obj0 = 0 ;
43385 PyObject * obj1 = 0 ;
43386 PyObject * obj2 = 0 ;
43387
43388 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43390 if (SWIG_arg_fail(1)) SWIG_fail;
43391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43392 if (SWIG_arg_fail(2)) SWIG_fail;
43393 {
43394 arg3 = &temp3;
43395 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43396 }
43397 {
43398 PyThreadState* __tstate = wxPyBeginAllowThreads();
43399 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43400
43401 wxPyEndAllowThreads(__tstate);
43402 if (PyErr_Occurred()) SWIG_fail;
43403 }
43404 {
43405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43406 }
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43414 PyObject *resultobj;
43415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43416 size_t arg2 ;
43417 wxGBPosition *arg3 = 0 ;
43418 bool result;
43419 wxGBPosition temp3 ;
43420 PyObject * obj0 = 0 ;
43421 PyObject * obj1 = 0 ;
43422 PyObject * obj2 = 0 ;
43423
43424 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43426 if (SWIG_arg_fail(1)) SWIG_fail;
43427 {
43428 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43429 if (SWIG_arg_fail(2)) SWIG_fail;
43430 }
43431 {
43432 arg3 = &temp3;
43433 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43438
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 {
43443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43444 }
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43452 int argc;
43453 PyObject *argv[4];
43454 int ii;
43455
43456 argc = PyObject_Length(args);
43457 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43458 argv[ii] = PyTuple_GetItem(args,ii);
43459 }
43460 if (argc == 3) {
43461 int _v;
43462 {
43463 void *ptr;
43464 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43465 _v = 0;
43466 PyErr_Clear();
43467 } else {
43468 _v = 1;
43469 }
43470 }
43471 if (_v) {
43472 {
43473 void *ptr;
43474 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43475 _v = 0;
43476 PyErr_Clear();
43477 } else {
43478 _v = 1;
43479 }
43480 }
43481 if (_v) {
43482 {
43483 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43484 }
43485 if (_v) {
43486 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43487 }
43488 }
43489 }
43490 }
43491 if (argc == 3) {
43492 int _v;
43493 {
43494 void *ptr;
43495 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43496 _v = 0;
43497 PyErr_Clear();
43498 } else {
43499 _v = 1;
43500 }
43501 }
43502 if (_v) {
43503 {
43504 void *ptr;
43505 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43506 _v = 0;
43507 PyErr_Clear();
43508 } else {
43509 _v = 1;
43510 }
43511 }
43512 if (_v) {
43513 {
43514 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43515 }
43516 if (_v) {
43517 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43518 }
43519 }
43520 }
43521 }
43522 if (argc == 3) {
43523 int _v;
43524 {
43525 void *ptr;
43526 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43527 _v = 0;
43528 PyErr_Clear();
43529 } else {
43530 _v = 1;
43531 }
43532 }
43533 if (_v) {
43534 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43535 if (_v) {
43536 {
43537 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43538 }
43539 if (_v) {
43540 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43541 }
43542 }
43543 }
43544 }
43545
43546 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43547 return NULL;
43548 }
43549
43550
43551 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43552 PyObject *resultobj;
43553 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43554 wxWindow *arg2 = (wxWindow *) 0 ;
43555 wxGBSpan result;
43556 PyObject * obj0 = 0 ;
43557 PyObject * obj1 = 0 ;
43558
43559 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43561 if (SWIG_arg_fail(1)) SWIG_fail;
43562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43563 if (SWIG_arg_fail(2)) SWIG_fail;
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__SWIG_1(PyObject *, PyObject *args) {
43583 PyObject *resultobj;
43584 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43585 wxSizer *arg2 = (wxSizer *) 0 ;
43586 wxGBSpan result;
43587 PyObject * obj0 = 0 ;
43588 PyObject * obj1 = 0 ;
43589
43590 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43592 if (SWIG_arg_fail(1)) SWIG_fail;
43593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43594 if (SWIG_arg_fail(2)) SWIG_fail;
43595 {
43596 PyThreadState* __tstate = wxPyBeginAllowThreads();
43597 result = (arg1)->GetItemSpan(arg2);
43598
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 {
43603 wxGBSpan * resultptr;
43604 resultptr = new wxGBSpan((wxGBSpan &)(result));
43605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43606 }
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43614 PyObject *resultobj;
43615 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43616 size_t arg2 ;
43617 wxGBSpan result;
43618 PyObject * obj0 = 0 ;
43619 PyObject * obj1 = 0 ;
43620
43621 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43623 if (SWIG_arg_fail(1)) SWIG_fail;
43624 {
43625 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43626 if (SWIG_arg_fail(2)) SWIG_fail;
43627 }
43628 {
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 result = (arg1)->GetItemSpan(arg2);
43631
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 {
43636 wxGBSpan * resultptr;
43637 resultptr = new wxGBSpan((wxGBSpan &)(result));
43638 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43639 }
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43647 int argc;
43648 PyObject *argv[3];
43649 int ii;
43650
43651 argc = PyObject_Length(args);
43652 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43653 argv[ii] = PyTuple_GetItem(args,ii);
43654 }
43655 if (argc == 2) {
43656 int _v;
43657 {
43658 void *ptr;
43659 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43660 _v = 0;
43661 PyErr_Clear();
43662 } else {
43663 _v = 1;
43664 }
43665 }
43666 if (_v) {
43667 {
43668 void *ptr;
43669 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43670 _v = 0;
43671 PyErr_Clear();
43672 } else {
43673 _v = 1;
43674 }
43675 }
43676 if (_v) {
43677 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43678 }
43679 }
43680 }
43681 if (argc == 2) {
43682 int _v;
43683 {
43684 void *ptr;
43685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43686 _v = 0;
43687 PyErr_Clear();
43688 } else {
43689 _v = 1;
43690 }
43691 }
43692 if (_v) {
43693 {
43694 void *ptr;
43695 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43696 _v = 0;
43697 PyErr_Clear();
43698 } else {
43699 _v = 1;
43700 }
43701 }
43702 if (_v) {
43703 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43704 }
43705 }
43706 }
43707 if (argc == 2) {
43708 int _v;
43709 {
43710 void *ptr;
43711 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43712 _v = 0;
43713 PyErr_Clear();
43714 } else {
43715 _v = 1;
43716 }
43717 }
43718 if (_v) {
43719 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43720 if (_v) {
43721 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43722 }
43723 }
43724 }
43725
43726 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43727 return NULL;
43728 }
43729
43730
43731 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43732 PyObject *resultobj;
43733 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43734 wxWindow *arg2 = (wxWindow *) 0 ;
43735 wxGBSpan *arg3 = 0 ;
43736 bool result;
43737 wxGBSpan temp3 ;
43738 PyObject * obj0 = 0 ;
43739 PyObject * obj1 = 0 ;
43740 PyObject * obj2 = 0 ;
43741
43742 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43744 if (SWIG_arg_fail(1)) SWIG_fail;
43745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43746 if (SWIG_arg_fail(2)) SWIG_fail;
43747 {
43748 arg3 = &temp3;
43749 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43750 }
43751 {
43752 PyThreadState* __tstate = wxPyBeginAllowThreads();
43753 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43754
43755 wxPyEndAllowThreads(__tstate);
43756 if (PyErr_Occurred()) SWIG_fail;
43757 }
43758 {
43759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43760 }
43761 return resultobj;
43762 fail:
43763 return NULL;
43764 }
43765
43766
43767 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43768 PyObject *resultobj;
43769 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43770 wxSizer *arg2 = (wxSizer *) 0 ;
43771 wxGBSpan *arg3 = 0 ;
43772 bool result;
43773 wxGBSpan temp3 ;
43774 PyObject * obj0 = 0 ;
43775 PyObject * obj1 = 0 ;
43776 PyObject * obj2 = 0 ;
43777
43778 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43780 if (SWIG_arg_fail(1)) SWIG_fail;
43781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43782 if (SWIG_arg_fail(2)) SWIG_fail;
43783 {
43784 arg3 = &temp3;
43785 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43786 }
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43790
43791 wxPyEndAllowThreads(__tstate);
43792 if (PyErr_Occurred()) SWIG_fail;
43793 }
43794 {
43795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43796 }
43797 return resultobj;
43798 fail:
43799 return NULL;
43800 }
43801
43802
43803 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43804 PyObject *resultobj;
43805 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43806 size_t arg2 ;
43807 wxGBSpan *arg3 = 0 ;
43808 bool result;
43809 wxGBSpan temp3 ;
43810 PyObject * obj0 = 0 ;
43811 PyObject * obj1 = 0 ;
43812 PyObject * obj2 = 0 ;
43813
43814 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43816 if (SWIG_arg_fail(1)) SWIG_fail;
43817 {
43818 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43819 if (SWIG_arg_fail(2)) SWIG_fail;
43820 }
43821 {
43822 arg3 = &temp3;
43823 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43824 }
43825 {
43826 PyThreadState* __tstate = wxPyBeginAllowThreads();
43827 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43828
43829 wxPyEndAllowThreads(__tstate);
43830 if (PyErr_Occurred()) SWIG_fail;
43831 }
43832 {
43833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43834 }
43835 return resultobj;
43836 fail:
43837 return NULL;
43838 }
43839
43840
43841 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43842 int argc;
43843 PyObject *argv[4];
43844 int ii;
43845
43846 argc = PyObject_Length(args);
43847 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43848 argv[ii] = PyTuple_GetItem(args,ii);
43849 }
43850 if (argc == 3) {
43851 int _v;
43852 {
43853 void *ptr;
43854 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43855 _v = 0;
43856 PyErr_Clear();
43857 } else {
43858 _v = 1;
43859 }
43860 }
43861 if (_v) {
43862 {
43863 void *ptr;
43864 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43865 _v = 0;
43866 PyErr_Clear();
43867 } else {
43868 _v = 1;
43869 }
43870 }
43871 if (_v) {
43872 {
43873 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43874 }
43875 if (_v) {
43876 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43877 }
43878 }
43879 }
43880 }
43881 if (argc == 3) {
43882 int _v;
43883 {
43884 void *ptr;
43885 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43886 _v = 0;
43887 PyErr_Clear();
43888 } else {
43889 _v = 1;
43890 }
43891 }
43892 if (_v) {
43893 {
43894 void *ptr;
43895 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43896 _v = 0;
43897 PyErr_Clear();
43898 } else {
43899 _v = 1;
43900 }
43901 }
43902 if (_v) {
43903 {
43904 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43905 }
43906 if (_v) {
43907 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43908 }
43909 }
43910 }
43911 }
43912 if (argc == 3) {
43913 int _v;
43914 {
43915 void *ptr;
43916 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43917 _v = 0;
43918 PyErr_Clear();
43919 } else {
43920 _v = 1;
43921 }
43922 }
43923 if (_v) {
43924 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43925 if (_v) {
43926 {
43927 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43928 }
43929 if (_v) {
43930 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43931 }
43932 }
43933 }
43934 }
43935
43936 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43937 return NULL;
43938 }
43939
43940
43941 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43942 PyObject *resultobj;
43943 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43944 wxWindow *arg2 = (wxWindow *) 0 ;
43945 wxGBSizerItem *result;
43946 PyObject * obj0 = 0 ;
43947 PyObject * obj1 = 0 ;
43948
43949 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43951 if (SWIG_arg_fail(1)) SWIG_fail;
43952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43953 if (SWIG_arg_fail(2)) SWIG_fail;
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43957
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43962 return resultobj;
43963 fail:
43964 return NULL;
43965 }
43966
43967
43968 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43969 PyObject *resultobj;
43970 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43971 wxSizer *arg2 = (wxSizer *) 0 ;
43972 wxGBSizerItem *result;
43973 PyObject * obj0 = 0 ;
43974 PyObject * obj1 = 0 ;
43975
43976 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43978 if (SWIG_arg_fail(1)) SWIG_fail;
43979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43980 if (SWIG_arg_fail(2)) SWIG_fail;
43981 {
43982 PyThreadState* __tstate = wxPyBeginAllowThreads();
43983 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43984
43985 wxPyEndAllowThreads(__tstate);
43986 if (PyErr_Occurred()) SWIG_fail;
43987 }
43988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43989 return resultobj;
43990 fail:
43991 return NULL;
43992 }
43993
43994
43995 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43996 int argc;
43997 PyObject *argv[3];
43998 int ii;
43999
44000 argc = PyObject_Length(args);
44001 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44002 argv[ii] = PyTuple_GetItem(args,ii);
44003 }
44004 if (argc == 2) {
44005 int _v;
44006 {
44007 void *ptr;
44008 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44009 _v = 0;
44010 PyErr_Clear();
44011 } else {
44012 _v = 1;
44013 }
44014 }
44015 if (_v) {
44016 {
44017 void *ptr;
44018 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44019 _v = 0;
44020 PyErr_Clear();
44021 } else {
44022 _v = 1;
44023 }
44024 }
44025 if (_v) {
44026 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44027 }
44028 }
44029 }
44030 if (argc == 2) {
44031 int _v;
44032 {
44033 void *ptr;
44034 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44035 _v = 0;
44036 PyErr_Clear();
44037 } else {
44038 _v = 1;
44039 }
44040 }
44041 if (_v) {
44042 {
44043 void *ptr;
44044 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44045 _v = 0;
44046 PyErr_Clear();
44047 } else {
44048 _v = 1;
44049 }
44050 }
44051 if (_v) {
44052 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44053 }
44054 }
44055 }
44056
44057 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44058 return NULL;
44059 }
44060
44061
44062 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44063 PyObject *resultobj;
44064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44065 wxGBPosition *arg2 = 0 ;
44066 wxGBSizerItem *result;
44067 wxGBPosition temp2 ;
44068 PyObject * obj0 = 0 ;
44069 PyObject * obj1 = 0 ;
44070 char *kwnames[] = {
44071 (char *) "self",(char *) "pos", NULL
44072 };
44073
44074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44076 if (SWIG_arg_fail(1)) SWIG_fail;
44077 {
44078 arg2 = &temp2;
44079 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44080 }
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44084
44085 wxPyEndAllowThreads(__tstate);
44086 if (PyErr_Occurred()) SWIG_fail;
44087 }
44088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44089 return resultobj;
44090 fail:
44091 return NULL;
44092 }
44093
44094
44095 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44096 PyObject *resultobj;
44097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44098 wxPoint *arg2 = 0 ;
44099 wxGBSizerItem *result;
44100 wxPoint temp2 ;
44101 PyObject * obj0 = 0 ;
44102 PyObject * obj1 = 0 ;
44103 char *kwnames[] = {
44104 (char *) "self",(char *) "pt", NULL
44105 };
44106
44107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44109 if (SWIG_arg_fail(1)) SWIG_fail;
44110 {
44111 arg2 = &temp2;
44112 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44113 }
44114 {
44115 PyThreadState* __tstate = wxPyBeginAllowThreads();
44116 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44117
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44129 PyObject *resultobj;
44130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44131 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44132 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44133 bool result;
44134 PyObject * obj0 = 0 ;
44135 PyObject * obj1 = 0 ;
44136 PyObject * obj2 = 0 ;
44137 char *kwnames[] = {
44138 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44139 };
44140
44141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44143 if (SWIG_arg_fail(1)) SWIG_fail;
44144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44145 if (SWIG_arg_fail(2)) SWIG_fail;
44146 if (obj2) {
44147 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44148 if (SWIG_arg_fail(3)) SWIG_fail;
44149 }
44150 {
44151 PyThreadState* __tstate = wxPyBeginAllowThreads();
44152 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44153
44154 wxPyEndAllowThreads(__tstate);
44155 if (PyErr_Occurred()) SWIG_fail;
44156 }
44157 {
44158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44159 }
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44167 PyObject *resultobj;
44168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44169 wxGBPosition *arg2 = 0 ;
44170 wxGBSpan *arg3 = 0 ;
44171 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44172 bool result;
44173 wxGBPosition temp2 ;
44174 wxGBSpan temp3 ;
44175 PyObject * obj0 = 0 ;
44176 PyObject * obj1 = 0 ;
44177 PyObject * obj2 = 0 ;
44178 PyObject * obj3 = 0 ;
44179 char *kwnames[] = {
44180 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44181 };
44182
44183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44185 if (SWIG_arg_fail(1)) SWIG_fail;
44186 {
44187 arg2 = &temp2;
44188 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44189 }
44190 {
44191 arg3 = &temp3;
44192 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44193 }
44194 if (obj3) {
44195 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44196 if (SWIG_arg_fail(4)) SWIG_fail;
44197 }
44198 {
44199 PyThreadState* __tstate = wxPyBeginAllowThreads();
44200 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44201
44202 wxPyEndAllowThreads(__tstate);
44203 if (PyErr_Occurred()) SWIG_fail;
44204 }
44205 {
44206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44207 }
44208 return resultobj;
44209 fail:
44210 return NULL;
44211 }
44212
44213
44214 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44215 PyObject *obj;
44216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44217 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44218 Py_INCREF(obj);
44219 return Py_BuildValue((char *)"");
44220 }
44221 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44222 PyObject *resultobj;
44223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44224 wxRelationship arg2 ;
44225 wxWindow *arg3 = (wxWindow *) 0 ;
44226 wxEdge arg4 ;
44227 int arg5 = (int) 0 ;
44228 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44229 PyObject * obj0 = 0 ;
44230 PyObject * obj1 = 0 ;
44231 PyObject * obj2 = 0 ;
44232 PyObject * obj3 = 0 ;
44233 PyObject * obj4 = 0 ;
44234 PyObject * obj5 = 0 ;
44235 char *kwnames[] = {
44236 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44237 };
44238
44239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44241 if (SWIG_arg_fail(1)) SWIG_fail;
44242 {
44243 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44244 if (SWIG_arg_fail(2)) SWIG_fail;
44245 }
44246 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44247 if (SWIG_arg_fail(3)) SWIG_fail;
44248 {
44249 arg4 = (wxEdge)(SWIG_As_int(obj3));
44250 if (SWIG_arg_fail(4)) SWIG_fail;
44251 }
44252 if (obj4) {
44253 {
44254 arg5 = (int)(SWIG_As_int(obj4));
44255 if (SWIG_arg_fail(5)) SWIG_fail;
44256 }
44257 }
44258 if (obj5) {
44259 {
44260 arg6 = (int)(SWIG_As_int(obj5));
44261 if (SWIG_arg_fail(6)) SWIG_fail;
44262 }
44263 }
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44267
44268 wxPyEndAllowThreads(__tstate);
44269 if (PyErr_Occurred()) SWIG_fail;
44270 }
44271 Py_INCREF(Py_None); resultobj = Py_None;
44272 return resultobj;
44273 fail:
44274 return NULL;
44275 }
44276
44277
44278 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44279 PyObject *resultobj;
44280 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44281 wxWindow *arg2 = (wxWindow *) 0 ;
44282 int arg3 = (int) 0 ;
44283 PyObject * obj0 = 0 ;
44284 PyObject * obj1 = 0 ;
44285 PyObject * obj2 = 0 ;
44286 char *kwnames[] = {
44287 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44288 };
44289
44290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44292 if (SWIG_arg_fail(1)) SWIG_fail;
44293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44294 if (SWIG_arg_fail(2)) SWIG_fail;
44295 if (obj2) {
44296 {
44297 arg3 = (int)(SWIG_As_int(obj2));
44298 if (SWIG_arg_fail(3)) SWIG_fail;
44299 }
44300 }
44301 {
44302 PyThreadState* __tstate = wxPyBeginAllowThreads();
44303 (arg1)->LeftOf(arg2,arg3);
44304
44305 wxPyEndAllowThreads(__tstate);
44306 if (PyErr_Occurred()) SWIG_fail;
44307 }
44308 Py_INCREF(Py_None); resultobj = Py_None;
44309 return resultobj;
44310 fail:
44311 return NULL;
44312 }
44313
44314
44315 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44316 PyObject *resultobj;
44317 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44318 wxWindow *arg2 = (wxWindow *) 0 ;
44319 int arg3 = (int) 0 ;
44320 PyObject * obj0 = 0 ;
44321 PyObject * obj1 = 0 ;
44322 PyObject * obj2 = 0 ;
44323 char *kwnames[] = {
44324 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44325 };
44326
44327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44329 if (SWIG_arg_fail(1)) SWIG_fail;
44330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44331 if (SWIG_arg_fail(2)) SWIG_fail;
44332 if (obj2) {
44333 {
44334 arg3 = (int)(SWIG_As_int(obj2));
44335 if (SWIG_arg_fail(3)) SWIG_fail;
44336 }
44337 }
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 (arg1)->RightOf(arg2,arg3);
44341
44342 wxPyEndAllowThreads(__tstate);
44343 if (PyErr_Occurred()) SWIG_fail;
44344 }
44345 Py_INCREF(Py_None); resultobj = Py_None;
44346 return resultobj;
44347 fail:
44348 return NULL;
44349 }
44350
44351
44352 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44353 PyObject *resultobj;
44354 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44355 wxWindow *arg2 = (wxWindow *) 0 ;
44356 int arg3 = (int) 0 ;
44357 PyObject * obj0 = 0 ;
44358 PyObject * obj1 = 0 ;
44359 PyObject * obj2 = 0 ;
44360 char *kwnames[] = {
44361 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44362 };
44363
44364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44366 if (SWIG_arg_fail(1)) SWIG_fail;
44367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44368 if (SWIG_arg_fail(2)) SWIG_fail;
44369 if (obj2) {
44370 {
44371 arg3 = (int)(SWIG_As_int(obj2));
44372 if (SWIG_arg_fail(3)) SWIG_fail;
44373 }
44374 }
44375 {
44376 PyThreadState* __tstate = wxPyBeginAllowThreads();
44377 (arg1)->Above(arg2,arg3);
44378
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 Py_INCREF(Py_None); resultobj = Py_None;
44383 return resultobj;
44384 fail:
44385 return NULL;
44386 }
44387
44388
44389 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44390 PyObject *resultobj;
44391 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44392 wxWindow *arg2 = (wxWindow *) 0 ;
44393 int arg3 = (int) 0 ;
44394 PyObject * obj0 = 0 ;
44395 PyObject * obj1 = 0 ;
44396 PyObject * obj2 = 0 ;
44397 char *kwnames[] = {
44398 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44399 };
44400
44401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44403 if (SWIG_arg_fail(1)) SWIG_fail;
44404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44405 if (SWIG_arg_fail(2)) SWIG_fail;
44406 if (obj2) {
44407 {
44408 arg3 = (int)(SWIG_As_int(obj2));
44409 if (SWIG_arg_fail(3)) SWIG_fail;
44410 }
44411 }
44412 {
44413 PyThreadState* __tstate = wxPyBeginAllowThreads();
44414 (arg1)->Below(arg2,arg3);
44415
44416 wxPyEndAllowThreads(__tstate);
44417 if (PyErr_Occurred()) SWIG_fail;
44418 }
44419 Py_INCREF(Py_None); resultobj = Py_None;
44420 return resultobj;
44421 fail:
44422 return NULL;
44423 }
44424
44425
44426 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44427 PyObject *resultobj;
44428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44429 wxWindow *arg2 = (wxWindow *) 0 ;
44430 wxEdge arg3 ;
44431 int arg4 = (int) 0 ;
44432 PyObject * obj0 = 0 ;
44433 PyObject * obj1 = 0 ;
44434 PyObject * obj2 = 0 ;
44435 PyObject * obj3 = 0 ;
44436 char *kwnames[] = {
44437 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44438 };
44439
44440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44442 if (SWIG_arg_fail(1)) SWIG_fail;
44443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44444 if (SWIG_arg_fail(2)) SWIG_fail;
44445 {
44446 arg3 = (wxEdge)(SWIG_As_int(obj2));
44447 if (SWIG_arg_fail(3)) SWIG_fail;
44448 }
44449 if (obj3) {
44450 {
44451 arg4 = (int)(SWIG_As_int(obj3));
44452 if (SWIG_arg_fail(4)) SWIG_fail;
44453 }
44454 }
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44458
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 Py_INCREF(Py_None); resultobj = Py_None;
44463 return resultobj;
44464 fail:
44465 return NULL;
44466 }
44467
44468
44469 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44470 PyObject *resultobj;
44471 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44472 wxWindow *arg2 = (wxWindow *) 0 ;
44473 wxEdge arg3 ;
44474 int arg4 ;
44475 PyObject * obj0 = 0 ;
44476 PyObject * obj1 = 0 ;
44477 PyObject * obj2 = 0 ;
44478 PyObject * obj3 = 0 ;
44479 char *kwnames[] = {
44480 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44481 };
44482
44483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44485 if (SWIG_arg_fail(1)) SWIG_fail;
44486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44487 if (SWIG_arg_fail(2)) SWIG_fail;
44488 {
44489 arg3 = (wxEdge)(SWIG_As_int(obj2));
44490 if (SWIG_arg_fail(3)) SWIG_fail;
44491 }
44492 {
44493 arg4 = (int)(SWIG_As_int(obj3));
44494 if (SWIG_arg_fail(4)) SWIG_fail;
44495 }
44496 {
44497 PyThreadState* __tstate = wxPyBeginAllowThreads();
44498 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44499
44500 wxPyEndAllowThreads(__tstate);
44501 if (PyErr_Occurred()) SWIG_fail;
44502 }
44503 Py_INCREF(Py_None); resultobj = Py_None;
44504 return resultobj;
44505 fail:
44506 return NULL;
44507 }
44508
44509
44510 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44511 PyObject *resultobj;
44512 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44513 int arg2 ;
44514 PyObject * obj0 = 0 ;
44515 PyObject * obj1 = 0 ;
44516 char *kwnames[] = {
44517 (char *) "self",(char *) "val", NULL
44518 };
44519
44520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44522 if (SWIG_arg_fail(1)) SWIG_fail;
44523 {
44524 arg2 = (int)(SWIG_As_int(obj1));
44525 if (SWIG_arg_fail(2)) SWIG_fail;
44526 }
44527 {
44528 PyThreadState* __tstate = wxPyBeginAllowThreads();
44529 (arg1)->Absolute(arg2);
44530
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 Py_INCREF(Py_None); resultobj = Py_None;
44535 return resultobj;
44536 fail:
44537 return NULL;
44538 }
44539
44540
44541 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44542 PyObject *resultobj;
44543 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44544 PyObject * obj0 = 0 ;
44545 char *kwnames[] = {
44546 (char *) "self", NULL
44547 };
44548
44549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44551 if (SWIG_arg_fail(1)) SWIG_fail;
44552 {
44553 PyThreadState* __tstate = wxPyBeginAllowThreads();
44554 (arg1)->Unconstrained();
44555
44556 wxPyEndAllowThreads(__tstate);
44557 if (PyErr_Occurred()) SWIG_fail;
44558 }
44559 Py_INCREF(Py_None); resultobj = Py_None;
44560 return resultobj;
44561 fail:
44562 return NULL;
44563 }
44564
44565
44566 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44567 PyObject *resultobj;
44568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44569 PyObject * obj0 = 0 ;
44570 char *kwnames[] = {
44571 (char *) "self", NULL
44572 };
44573
44574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44576 if (SWIG_arg_fail(1)) SWIG_fail;
44577 {
44578 PyThreadState* __tstate = wxPyBeginAllowThreads();
44579 (arg1)->AsIs();
44580
44581 wxPyEndAllowThreads(__tstate);
44582 if (PyErr_Occurred()) SWIG_fail;
44583 }
44584 Py_INCREF(Py_None); resultobj = Py_None;
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44592 PyObject *resultobj;
44593 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44594 wxWindow *result;
44595 PyObject * obj0 = 0 ;
44596 char *kwnames[] = {
44597 (char *) "self", NULL
44598 };
44599
44600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44602 if (SWIG_arg_fail(1)) SWIG_fail;
44603 {
44604 PyThreadState* __tstate = wxPyBeginAllowThreads();
44605 result = (wxWindow *)(arg1)->GetOtherWindow();
44606
44607 wxPyEndAllowThreads(__tstate);
44608 if (PyErr_Occurred()) SWIG_fail;
44609 }
44610 {
44611 resultobj = wxPyMake_wxObject(result, 0);
44612 }
44613 return resultobj;
44614 fail:
44615 return NULL;
44616 }
44617
44618
44619 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44620 PyObject *resultobj;
44621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44622 wxEdge result;
44623 PyObject * obj0 = 0 ;
44624 char *kwnames[] = {
44625 (char *) "self", NULL
44626 };
44627
44628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44630 if (SWIG_arg_fail(1)) SWIG_fail;
44631 {
44632 PyThreadState* __tstate = wxPyBeginAllowThreads();
44633 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44634
44635 wxPyEndAllowThreads(__tstate);
44636 if (PyErr_Occurred()) SWIG_fail;
44637 }
44638 resultobj = SWIG_From_int((result));
44639 return resultobj;
44640 fail:
44641 return NULL;
44642 }
44643
44644
44645 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44646 PyObject *resultobj;
44647 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44648 wxEdge arg2 ;
44649 PyObject * obj0 = 0 ;
44650 PyObject * obj1 = 0 ;
44651 char *kwnames[] = {
44652 (char *) "self",(char *) "which", NULL
44653 };
44654
44655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44657 if (SWIG_arg_fail(1)) SWIG_fail;
44658 {
44659 arg2 = (wxEdge)(SWIG_As_int(obj1));
44660 if (SWIG_arg_fail(2)) SWIG_fail;
44661 }
44662 {
44663 PyThreadState* __tstate = wxPyBeginAllowThreads();
44664 (arg1)->SetEdge((wxEdge )arg2);
44665
44666 wxPyEndAllowThreads(__tstate);
44667 if (PyErr_Occurred()) SWIG_fail;
44668 }
44669 Py_INCREF(Py_None); resultobj = Py_None;
44670 return resultobj;
44671 fail:
44672 return NULL;
44673 }
44674
44675
44676 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44677 PyObject *resultobj;
44678 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44679 int arg2 ;
44680 PyObject * obj0 = 0 ;
44681 PyObject * obj1 = 0 ;
44682 char *kwnames[] = {
44683 (char *) "self",(char *) "v", NULL
44684 };
44685
44686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44688 if (SWIG_arg_fail(1)) SWIG_fail;
44689 {
44690 arg2 = (int)(SWIG_As_int(obj1));
44691 if (SWIG_arg_fail(2)) SWIG_fail;
44692 }
44693 {
44694 PyThreadState* __tstate = wxPyBeginAllowThreads();
44695 (arg1)->SetValue(arg2);
44696
44697 wxPyEndAllowThreads(__tstate);
44698 if (PyErr_Occurred()) SWIG_fail;
44699 }
44700 Py_INCREF(Py_None); resultobj = Py_None;
44701 return resultobj;
44702 fail:
44703 return NULL;
44704 }
44705
44706
44707 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44708 PyObject *resultobj;
44709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44710 int result;
44711 PyObject * obj0 = 0 ;
44712 char *kwnames[] = {
44713 (char *) "self", NULL
44714 };
44715
44716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44718 if (SWIG_arg_fail(1)) SWIG_fail;
44719 {
44720 PyThreadState* __tstate = wxPyBeginAllowThreads();
44721 result = (int)(arg1)->GetMargin();
44722
44723 wxPyEndAllowThreads(__tstate);
44724 if (PyErr_Occurred()) SWIG_fail;
44725 }
44726 {
44727 resultobj = SWIG_From_int((int)(result));
44728 }
44729 return resultobj;
44730 fail:
44731 return NULL;
44732 }
44733
44734
44735 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44736 PyObject *resultobj;
44737 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44738 int arg2 ;
44739 PyObject * obj0 = 0 ;
44740 PyObject * obj1 = 0 ;
44741 char *kwnames[] = {
44742 (char *) "self",(char *) "m", NULL
44743 };
44744
44745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44747 if (SWIG_arg_fail(1)) SWIG_fail;
44748 {
44749 arg2 = (int)(SWIG_As_int(obj1));
44750 if (SWIG_arg_fail(2)) SWIG_fail;
44751 }
44752 {
44753 PyThreadState* __tstate = wxPyBeginAllowThreads();
44754 (arg1)->SetMargin(arg2);
44755
44756 wxPyEndAllowThreads(__tstate);
44757 if (PyErr_Occurred()) SWIG_fail;
44758 }
44759 Py_INCREF(Py_None); resultobj = Py_None;
44760 return resultobj;
44761 fail:
44762 return NULL;
44763 }
44764
44765
44766 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44767 PyObject *resultobj;
44768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44769 int result;
44770 PyObject * obj0 = 0 ;
44771 char *kwnames[] = {
44772 (char *) "self", NULL
44773 };
44774
44775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44777 if (SWIG_arg_fail(1)) SWIG_fail;
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44781
44782 wxPyEndAllowThreads(__tstate);
44783 if (PyErr_Occurred()) SWIG_fail;
44784 }
44785 {
44786 resultobj = SWIG_From_int((int)(result));
44787 }
44788 return resultobj;
44789 fail:
44790 return NULL;
44791 }
44792
44793
44794 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44795 PyObject *resultobj;
44796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44797 int result;
44798 PyObject * obj0 = 0 ;
44799 char *kwnames[] = {
44800 (char *) "self", NULL
44801 };
44802
44803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44805 if (SWIG_arg_fail(1)) SWIG_fail;
44806 {
44807 PyThreadState* __tstate = wxPyBeginAllowThreads();
44808 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44809
44810 wxPyEndAllowThreads(__tstate);
44811 if (PyErr_Occurred()) SWIG_fail;
44812 }
44813 {
44814 resultobj = SWIG_From_int((int)(result));
44815 }
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44823 PyObject *resultobj;
44824 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44825 int result;
44826 PyObject * obj0 = 0 ;
44827 char *kwnames[] = {
44828 (char *) "self", NULL
44829 };
44830
44831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44833 if (SWIG_arg_fail(1)) SWIG_fail;
44834 {
44835 PyThreadState* __tstate = wxPyBeginAllowThreads();
44836 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44837
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 {
44842 resultobj = SWIG_From_int((int)(result));
44843 }
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44851 PyObject *resultobj;
44852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44853 bool result;
44854 PyObject * obj0 = 0 ;
44855 char *kwnames[] = {
44856 (char *) "self", NULL
44857 };
44858
44859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44861 if (SWIG_arg_fail(1)) SWIG_fail;
44862 {
44863 PyThreadState* __tstate = wxPyBeginAllowThreads();
44864 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44865
44866 wxPyEndAllowThreads(__tstate);
44867 if (PyErr_Occurred()) SWIG_fail;
44868 }
44869 {
44870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44871 }
44872 return resultobj;
44873 fail:
44874 return NULL;
44875 }
44876
44877
44878 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44879 PyObject *resultobj;
44880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44881 bool arg2 ;
44882 PyObject * obj0 = 0 ;
44883 PyObject * obj1 = 0 ;
44884 char *kwnames[] = {
44885 (char *) "self",(char *) "d", NULL
44886 };
44887
44888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44890 if (SWIG_arg_fail(1)) SWIG_fail;
44891 {
44892 arg2 = (bool)(SWIG_As_bool(obj1));
44893 if (SWIG_arg_fail(2)) SWIG_fail;
44894 }
44895 {
44896 PyThreadState* __tstate = wxPyBeginAllowThreads();
44897 (arg1)->SetDone(arg2);
44898
44899 wxPyEndAllowThreads(__tstate);
44900 if (PyErr_Occurred()) SWIG_fail;
44901 }
44902 Py_INCREF(Py_None); resultobj = Py_None;
44903 return resultobj;
44904 fail:
44905 return NULL;
44906 }
44907
44908
44909 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44910 PyObject *resultobj;
44911 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44912 wxRelationship result;
44913 PyObject * obj0 = 0 ;
44914 char *kwnames[] = {
44915 (char *) "self", NULL
44916 };
44917
44918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44920 if (SWIG_arg_fail(1)) SWIG_fail;
44921 {
44922 PyThreadState* __tstate = wxPyBeginAllowThreads();
44923 result = (wxRelationship)(arg1)->GetRelationship();
44924
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 resultobj = SWIG_From_int((result));
44929 return resultobj;
44930 fail:
44931 return NULL;
44932 }
44933
44934
44935 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44936 PyObject *resultobj;
44937 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44938 wxRelationship arg2 ;
44939 PyObject * obj0 = 0 ;
44940 PyObject * obj1 = 0 ;
44941 char *kwnames[] = {
44942 (char *) "self",(char *) "r", NULL
44943 };
44944
44945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44947 if (SWIG_arg_fail(1)) SWIG_fail;
44948 {
44949 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44950 if (SWIG_arg_fail(2)) SWIG_fail;
44951 }
44952 {
44953 PyThreadState* __tstate = wxPyBeginAllowThreads();
44954 (arg1)->SetRelationship((wxRelationship )arg2);
44955
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 Py_INCREF(Py_None); resultobj = Py_None;
44960 return resultobj;
44961 fail:
44962 return NULL;
44963 }
44964
44965
44966 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44967 PyObject *resultobj;
44968 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44969 wxWindow *arg2 = (wxWindow *) 0 ;
44970 bool result;
44971 PyObject * obj0 = 0 ;
44972 PyObject * obj1 = 0 ;
44973 char *kwnames[] = {
44974 (char *) "self",(char *) "otherW", NULL
44975 };
44976
44977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44979 if (SWIG_arg_fail(1)) SWIG_fail;
44980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44981 if (SWIG_arg_fail(2)) SWIG_fail;
44982 {
44983 PyThreadState* __tstate = wxPyBeginAllowThreads();
44984 result = (bool)(arg1)->ResetIfWin(arg2);
44985
44986 wxPyEndAllowThreads(__tstate);
44987 if (PyErr_Occurred()) SWIG_fail;
44988 }
44989 {
44990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44991 }
44992 return resultobj;
44993 fail:
44994 return NULL;
44995 }
44996
44997
44998 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44999 PyObject *resultobj;
45000 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45001 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45002 wxWindow *arg3 = (wxWindow *) 0 ;
45003 bool result;
45004 PyObject * obj0 = 0 ;
45005 PyObject * obj1 = 0 ;
45006 PyObject * obj2 = 0 ;
45007 char *kwnames[] = {
45008 (char *) "self",(char *) "constraints",(char *) "win", NULL
45009 };
45010
45011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45013 if (SWIG_arg_fail(1)) SWIG_fail;
45014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45015 if (SWIG_arg_fail(2)) SWIG_fail;
45016 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45017 if (SWIG_arg_fail(3)) SWIG_fail;
45018 {
45019 PyThreadState* __tstate = wxPyBeginAllowThreads();
45020 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45021
45022 wxPyEndAllowThreads(__tstate);
45023 if (PyErr_Occurred()) SWIG_fail;
45024 }
45025 {
45026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45027 }
45028 return resultobj;
45029 fail:
45030 return NULL;
45031 }
45032
45033
45034 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45035 PyObject *resultobj;
45036 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45037 wxEdge arg2 ;
45038 wxWindow *arg3 = (wxWindow *) 0 ;
45039 wxWindow *arg4 = (wxWindow *) 0 ;
45040 int result;
45041 PyObject * obj0 = 0 ;
45042 PyObject * obj1 = 0 ;
45043 PyObject * obj2 = 0 ;
45044 PyObject * obj3 = 0 ;
45045 char *kwnames[] = {
45046 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45047 };
45048
45049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45051 if (SWIG_arg_fail(1)) SWIG_fail;
45052 {
45053 arg2 = (wxEdge)(SWIG_As_int(obj1));
45054 if (SWIG_arg_fail(2)) SWIG_fail;
45055 }
45056 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45057 if (SWIG_arg_fail(3)) SWIG_fail;
45058 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45059 if (SWIG_arg_fail(4)) SWIG_fail;
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45063
45064 wxPyEndAllowThreads(__tstate);
45065 if (PyErr_Occurred()) SWIG_fail;
45066 }
45067 {
45068 resultobj = SWIG_From_int((int)(result));
45069 }
45070 return resultobj;
45071 fail:
45072 return NULL;
45073 }
45074
45075
45076 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45077 PyObject *obj;
45078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45079 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45080 Py_INCREF(obj);
45081 return Py_BuildValue((char *)"");
45082 }
45083 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45084 PyObject *resultobj;
45085 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45086 wxIndividualLayoutConstraint *result;
45087 PyObject * obj0 = 0 ;
45088 char *kwnames[] = {
45089 (char *) "self", NULL
45090 };
45091
45092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45094 if (SWIG_arg_fail(1)) SWIG_fail;
45095 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45096
45097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45098 return resultobj;
45099 fail:
45100 return NULL;
45101 }
45102
45103
45104 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45105 PyObject *resultobj;
45106 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45107 wxIndividualLayoutConstraint *result;
45108 PyObject * obj0 = 0 ;
45109 char *kwnames[] = {
45110 (char *) "self", NULL
45111 };
45112
45113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45115 if (SWIG_arg_fail(1)) SWIG_fail;
45116 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45117
45118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj;
45127 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45128 wxIndividualLayoutConstraint *result;
45129 PyObject * obj0 = 0 ;
45130 char *kwnames[] = {
45131 (char *) "self", NULL
45132 };
45133
45134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45136 if (SWIG_arg_fail(1)) SWIG_fail;
45137 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45138
45139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45140 return resultobj;
45141 fail:
45142 return NULL;
45143 }
45144
45145
45146 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45147 PyObject *resultobj;
45148 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45149 wxIndividualLayoutConstraint *result;
45150 PyObject * obj0 = 0 ;
45151 char *kwnames[] = {
45152 (char *) "self", NULL
45153 };
45154
45155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45157 if (SWIG_arg_fail(1)) SWIG_fail;
45158 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45159
45160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45161 return resultobj;
45162 fail:
45163 return NULL;
45164 }
45165
45166
45167 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45168 PyObject *resultobj;
45169 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45170 wxIndividualLayoutConstraint *result;
45171 PyObject * obj0 = 0 ;
45172 char *kwnames[] = {
45173 (char *) "self", NULL
45174 };
45175
45176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45178 if (SWIG_arg_fail(1)) SWIG_fail;
45179 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45180
45181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45182 return resultobj;
45183 fail:
45184 return NULL;
45185 }
45186
45187
45188 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45189 PyObject *resultobj;
45190 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45191 wxIndividualLayoutConstraint *result;
45192 PyObject * obj0 = 0 ;
45193 char *kwnames[] = {
45194 (char *) "self", NULL
45195 };
45196
45197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45199 if (SWIG_arg_fail(1)) SWIG_fail;
45200 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45201
45202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45203 return resultobj;
45204 fail:
45205 return NULL;
45206 }
45207
45208
45209 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45210 PyObject *resultobj;
45211 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45212 wxIndividualLayoutConstraint *result;
45213 PyObject * obj0 = 0 ;
45214 char *kwnames[] = {
45215 (char *) "self", NULL
45216 };
45217
45218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45220 if (SWIG_arg_fail(1)) SWIG_fail;
45221 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45222
45223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45224 return resultobj;
45225 fail:
45226 return NULL;
45227 }
45228
45229
45230 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45231 PyObject *resultobj;
45232 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45233 wxIndividualLayoutConstraint *result;
45234 PyObject * obj0 = 0 ;
45235 char *kwnames[] = {
45236 (char *) "self", NULL
45237 };
45238
45239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45241 if (SWIG_arg_fail(1)) SWIG_fail;
45242 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45243
45244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45245 return resultobj;
45246 fail:
45247 return NULL;
45248 }
45249
45250
45251 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45252 PyObject *resultobj;
45253 wxLayoutConstraints *result;
45254 char *kwnames[] = {
45255 NULL
45256 };
45257
45258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45259 {
45260 PyThreadState* __tstate = wxPyBeginAllowThreads();
45261 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45262
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45267 return resultobj;
45268 fail:
45269 return NULL;
45270 }
45271
45272
45273 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45274 PyObject *resultobj;
45275 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45276 wxWindow *arg2 = (wxWindow *) 0 ;
45277 int *arg3 = (int *) 0 ;
45278 bool result;
45279 int temp3 ;
45280 int res3 = 0 ;
45281 PyObject * obj0 = 0 ;
45282 PyObject * obj1 = 0 ;
45283 char *kwnames[] = {
45284 (char *) "self",(char *) "win", NULL
45285 };
45286
45287 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45290 if (SWIG_arg_fail(1)) SWIG_fail;
45291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45292 if (SWIG_arg_fail(2)) SWIG_fail;
45293 {
45294 PyThreadState* __tstate = wxPyBeginAllowThreads();
45295 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45296
45297 wxPyEndAllowThreads(__tstate);
45298 if (PyErr_Occurred()) SWIG_fail;
45299 }
45300 {
45301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45302 }
45303 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45304 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45305 return resultobj;
45306 fail:
45307 return NULL;
45308 }
45309
45310
45311 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45312 PyObject *resultobj;
45313 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45314 bool result;
45315 PyObject * obj0 = 0 ;
45316 char *kwnames[] = {
45317 (char *) "self", NULL
45318 };
45319
45320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45322 if (SWIG_arg_fail(1)) SWIG_fail;
45323 {
45324 PyThreadState* __tstate = wxPyBeginAllowThreads();
45325 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45326
45327 wxPyEndAllowThreads(__tstate);
45328 if (PyErr_Occurred()) SWIG_fail;
45329 }
45330 {
45331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45332 }
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45340 PyObject *obj;
45341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45342 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45343 Py_INCREF(obj);
45344 return Py_BuildValue((char *)"");
45345 }
45346 static PyMethodDef SwigMethods[] = {
45347 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45348 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45349 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45352 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45373 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45386 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45401 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45455 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45483 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45502 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45504 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45512 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45513 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45525 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45537 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45541 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45547 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45557 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45567 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45574 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45656 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45658 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45660 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45662 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45666 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45668 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45670 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45672 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45674 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45676 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45678 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45692 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45710 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45713 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45716 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45728 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45733 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45739 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45745 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45808 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45815 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45851 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45861 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45869 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45871 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45874 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45878 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45881 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45884 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45886 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45891 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45899 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45903 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45906 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45908 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45912 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45929 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45931 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45934 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45936 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45940 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45944 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45955 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45961 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45965 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45977 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45982 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45986 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46031 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46051 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46062 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46072 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46244 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46286 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46301 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46304 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46359 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46386 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46430 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46438 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46457 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46458 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46495 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46525 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46528 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46532 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46535 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46545 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46557 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46569 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46579 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46589 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46610 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46611 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46612 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46613 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46614 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46619 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46646 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46658 { NULL, NULL, 0, NULL }
46659 };
46660
46661
46662 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46663
46664 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46665 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46666 }
46667 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46668 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46669 }
46670 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46671 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46672 }
46673 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46674 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46675 }
46676 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46677 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46678 }
46679 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46680 return (void *)((wxSizer *) ((wxGridSizer *) x));
46681 }
46682 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46683 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46684 }
46685 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46686 return (void *)((wxSizer *) ((wxPySizer *) x));
46687 }
46688 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46689 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46690 }
46691 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46692 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46693 }
46694 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46696 }
46697 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46699 }
46700 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46702 }
46703 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46705 }
46706 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46708 }
46709 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46711 }
46712 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46714 }
46715 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46717 }
46718 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) ((wxPyEvent *) x));
46720 }
46721 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46723 }
46724 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46726 }
46727 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46729 }
46730 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46732 }
46733 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46735 }
46736 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46738 }
46739 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46741 }
46742 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46743 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46744 }
46745 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46746 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46747 }
46748 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46749 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46750 }
46751 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46752 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46753 }
46754 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46755 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46756 }
46757 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46758 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46759 }
46760 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46761 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46762 }
46763 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46764 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46765 }
46766 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46767 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46768 }
46769 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46770 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46771 }
46772 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46773 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46774 }
46775 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46776 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46777 }
46778 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46779 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46780 }
46781 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46782 return (void *)((wxEvent *) ((wxShowEvent *) x));
46783 }
46784 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46785 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46786 }
46787 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46788 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46789 }
46790 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46791 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46792 }
46793 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46794 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46795 }
46796 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46797 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46798 }
46799 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46800 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46801 }
46802 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46803 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46804 }
46805 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46806 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46807 }
46808 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46809 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46810 }
46811 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46812 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46813 }
46814 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46815 return (void *)((wxControl *) ((wxControlWithItems *) x));
46816 }
46817 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46818 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46819 }
46820 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46821 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46822 }
46823 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46824 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46825 }
46826 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46827 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46828 }
46829 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46830 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46831 }
46832 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46833 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46834 }
46835 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46836 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46837 }
46838 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46839 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46840 }
46841 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46842 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46843 }
46844 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46845 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46846 }
46847 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46848 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46849 }
46850 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46851 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46852 }
46853 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46854 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46855 }
46856 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46857 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46858 }
46859 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46860 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46861 }
46862 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46863 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46864 }
46865 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46866 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46867 }
46868 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46869 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46870 }
46871 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46872 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46873 }
46874 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46875 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46876 }
46877 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46878 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46879 }
46880 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46881 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46882 }
46883 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46884 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46885 }
46886 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46887 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46888 }
46889 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46890 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46891 }
46892 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46893 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46894 }
46895 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46896 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46897 }
46898 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46899 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46900 }
46901 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46902 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46903 }
46904 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46906 }
46907 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46909 }
46910 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) ((wxSizerItem *) x));
46912 }
46913 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46915 }
46916 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46918 }
46919 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46921 }
46922 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46924 }
46925 static void *_p_wxSizerTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) ((wxSizer *) x));
46927 }
46928 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46930 }
46931 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46933 }
46934 static void *_p_wxEventTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) ((wxEvent *) x));
46936 }
46937 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46939 }
46940 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46942 }
46943 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46945 }
46946 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46948 }
46949 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46951 }
46952 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46954 }
46955 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46957 }
46958 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46960 }
46961 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46963 }
46964 static void *_p_wxControlTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46966 }
46967 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46969 }
46970 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) ((wxFSFile *) x));
46972 }
46973 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46975 }
46976 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46978 }
46979 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46981 }
46982 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46984 }
46985 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) ((wxMenuItem *) x));
46987 }
46988 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46990 }
46991 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46993 }
46994 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46996 }
46997 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46999 }
47000 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47002 }
47003 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47005 }
47006 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47008 }
47009 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47011 }
47012 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47014 }
47015 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47017 }
47018 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47020 }
47021 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47023 }
47024 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47026 }
47027 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47029 }
47030 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47032 }
47033 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47035 }
47036 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47038 }
47039 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47041 }
47042 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47044 }
47045 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) ((wxImageHandler *) x));
47047 }
47048 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47050 }
47051 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) ((wxEvtHandler *) x));
47053 }
47054 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47056 }
47057 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47059 }
47060 static void *_p_wxImageTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) ((wxImage *) x));
47062 }
47063 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47065 }
47066 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47068 }
47069 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47071 }
47072 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47074 }
47075 static void *_p_wxWindowTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47077 }
47078 static void *_p_wxMenuTo_p_wxObject(void *x) {
47079 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47080 }
47081 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47082 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47083 }
47084 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47085 return (void *)((wxObject *) ((wxFileSystem *) x));
47086 }
47087 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47088 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47089 }
47090 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47091 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47092 }
47093 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47094 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47095 }
47096 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47097 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47098 }
47099 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47100 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47101 }
47102 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47103 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47104 }
47105 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47106 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47107 }
47108 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47109 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47110 }
47111 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47112 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47113 }
47114 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47115 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47116 }
47117 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47118 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47119 }
47120 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47121 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47122 }
47123 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47124 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47125 }
47126 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47127 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47128 }
47129 static void *_p_wxControlTo_p_wxWindow(void *x) {
47130 return (void *)((wxWindow *) ((wxControl *) x));
47131 }
47132 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47133 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47134 }
47135 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47136 return (void *)((wxWindow *) ((wxMenuBar *) x));
47137 }
47138 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47139 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47140 }
47141 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47142 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47143 }
47144 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47145 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47146 }
47147 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47148 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47149 }
47150 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47151 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47152 }
47153 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47154 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47155 }
47156 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47157 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47158 }
47159 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47160 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47161 }
47162 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47163 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47164 }
47165 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47166 return (void *)((wxValidator *) ((wxPyValidator *) x));
47167 }
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47281 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}};
47282 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}};
47283 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}};
47284 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}};
47285 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}};
47286 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}};
47287 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}};
47288 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}};
47289 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}};
47290 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}};
47291 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}};
47292 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}};
47293 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}};
47294 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}};
47295 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}};
47296
47297 static swig_type_info *swig_types_initial[] = {
47298 _swigt__p_wxLayoutConstraints,
47299 _swigt__p_wxRealPoint,
47300 _swigt__p_wxSizerItem,
47301 _swigt__p_wxGBSizerItem,
47302 _swigt__p_wxScrollEvent,
47303 _swigt__p_wxEventLoop,
47304 _swigt__p_wxIndividualLayoutConstraint,
47305 _swigt__p_wxSizer,
47306 _swigt__p_wxBoxSizer,
47307 _swigt__p_wxStaticBoxSizer,
47308 _swigt__p_wxGridBagSizer,
47309 _swigt__p_wxAcceleratorEntry,
47310 _swigt__p_wxUpdateUIEvent,
47311 _swigt__p_wxEvent,
47312 _swigt__p_buffer,
47313 _swigt__p_wxMenu,
47314 _swigt__p_wxGridSizer,
47315 _swigt__p_wxFlexGridSizer,
47316 _swigt__p_wxInitDialogEvent,
47317 _swigt__p_wxItemContainer,
47318 _swigt__p_wxNcPaintEvent,
47319 _swigt__p_wxPaintEvent,
47320 _swigt__p_wxSysColourChangedEvent,
47321 _swigt__p_wxMouseCaptureChangedEvent,
47322 _swigt__p_wxDisplayChangedEvent,
47323 _swigt__p_wxPaletteChangedEvent,
47324 _swigt__p_wxControl,
47325 _swigt__p_wxFont,
47326 _swigt__p_wxMenuBarBase,
47327 _swigt__p_wxSetCursorEvent,
47328 _swigt__p_wxFSFile,
47329 _swigt__p_wxCaret,
47330 _swigt__ptrdiff_t,
47331 _swigt__std__ptrdiff_t,
47332 _swigt__p_wxRegion,
47333 _swigt__p_wxPoint2D,
47334 _swigt__p_int,
47335 _swigt__p_wxSize,
47336 _swigt__p_wxDC,
47337 _swigt__p_wxPySizer,
47338 _swigt__p_wxVisualAttributes,
47339 _swigt__p_wxNotifyEvent,
47340 _swigt__p_wxPyEvent,
47341 _swigt__p_wxPropagationDisabler,
47342 _swigt__p_form_ops_t,
47343 _swigt__p_wxAppTraits,
47344 _swigt__p_wxArrayString,
47345 _swigt__p_wxShowEvent,
47346 _swigt__p_wxToolTip,
47347 _swigt__p_wxMoveEvent,
47348 _swigt__p_wxSizeEvent,
47349 _swigt__p_wxActivateEvent,
47350 _swigt__p_wxIconizeEvent,
47351 _swigt__p_wxMaximizeEvent,
47352 _swigt__p_wxQueryNewPaletteEvent,
47353 _swigt__p_wxWindowCreateEvent,
47354 _swigt__p_wxIdleEvent,
47355 _swigt__p_wxDateEvent,
47356 _swigt__p_wxMenuItem,
47357 _swigt__p_wxStaticBox,
47358 _swigt__p_long,
47359 _swigt__p_wxDuplexMode,
47360 _swigt__p_wxTIFFHandler,
47361 _swigt__p_wxXPMHandler,
47362 _swigt__p_wxPNMHandler,
47363 _swigt__p_wxJPEGHandler,
47364 _swigt__p_wxPCXHandler,
47365 _swigt__p_wxGIFHandler,
47366 _swigt__p_wxPNGHandler,
47367 _swigt__p_wxANIHandler,
47368 _swigt__p_wxMemoryFSHandler,
47369 _swigt__p_wxZipFSHandler,
47370 _swigt__p_wxInternetFSHandler,
47371 _swigt__p_wxPyFileSystemHandler,
47372 _swigt__p_wxEvtHandler,
47373 _swigt__p_wxCURHandler,
47374 _swigt__p_wxICOHandler,
47375 _swigt__p_wxBMPHandler,
47376 _swigt__p_wxImageHandler,
47377 _swigt__p_wxFileSystemHandler,
47378 _swigt__p_wxRect,
47379 _swigt__p_wxButton,
47380 _swigt__p_wxGBSpan,
47381 _swigt__p_wxPropagateOnce,
47382 _swigt__p_wxAcceleratorTable,
47383 _swigt__p_wxStdDialogButtonSizer,
47384 _swigt__p_char,
47385 _swigt__p_wxGBPosition,
47386 _swigt__p_wxImage,
47387 _swigt__p_wxFrame,
47388 _swigt__p_wxScrollWinEvent,
47389 _swigt__p_wxPaperSize,
47390 _swigt__p_wxImageHistogram,
47391 _swigt__p_wxPoint,
47392 _swigt__p_wxCursor,
47393 _swigt__p_wxObject,
47394 _swigt__p_wxInputStream,
47395 _swigt__p_wxOutputStream,
47396 _swigt__p_wxPyInputStream,
47397 _swigt__p_wxDateTime,
47398 _swigt__p_wxKeyEvent,
47399 _swigt__p_wxNavigationKeyEvent,
47400 _swigt__p_wxWindowDestroyEvent,
47401 _swigt__p_unsigned_long,
47402 _swigt__p_wxWindow,
47403 _swigt__p_wxMenuBar,
47404 _swigt__p_wxFileSystem,
47405 _swigt__p_wxBitmap,
47406 _swigt__unsigned_int,
47407 _swigt__p_unsigned_int,
47408 _swigt__p_wxMenuEvent,
47409 _swigt__p_wxContextMenuEvent,
47410 _swigt__p_unsigned_char,
47411 _swigt__p_wxEraseEvent,
47412 _swigt__p_wxMouseEvent,
47413 _swigt__p_wxCloseEvent,
47414 _swigt__p_wxPyApp,
47415 _swigt__p_wxCommandEvent,
47416 _swigt__p_wxPyCommandEvent,
47417 _swigt__p_wxPyDropTarget,
47418 _swigt__p_wxQuantize,
47419 _swigt__p_wxFocusEvent,
47420 _swigt__p_wxChildFocusEvent,
47421 _swigt__p_wxDropFilesEvent,
47422 _swigt__p_wxControlWithItems,
47423 _swigt__p_wxColour,
47424 _swigt__p_wxValidator,
47425 _swigt__p_wxPyValidator,
47426 0
47427 };
47428
47429
47430 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47431
47432 static swig_const_info swig_const_table[] = {
47433 {0, 0, 0, 0.0, 0, 0}};
47434
47435 #ifdef __cplusplus
47436 }
47437 #endif
47438
47439
47440 #ifdef __cplusplus
47441 extern "C" {
47442 #endif
47443
47444 /* Python-specific SWIG API */
47445 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47446 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47447 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47448
47449 /* -----------------------------------------------------------------------------
47450 * global variable support code.
47451 * ----------------------------------------------------------------------------- */
47452
47453 typedef struct swig_globalvar {
47454 char *name; /* Name of global variable */
47455 PyObject *(*get_attr)(); /* Return the current value */
47456 int (*set_attr)(PyObject *); /* Set the value */
47457 struct swig_globalvar *next;
47458 } swig_globalvar;
47459
47460 typedef struct swig_varlinkobject {
47461 PyObject_HEAD
47462 swig_globalvar *vars;
47463 } swig_varlinkobject;
47464
47465 static PyObject *
47466 swig_varlink_repr(swig_varlinkobject *v) {
47467 v = v;
47468 return PyString_FromString("<Swig global variables>");
47469 }
47470
47471 static int
47472 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47473 swig_globalvar *var;
47474 flags = flags;
47475 fprintf(fp,"Swig global variables { ");
47476 for (var = v->vars; var; var=var->next) {
47477 fprintf(fp,"%s", var->name);
47478 if (var->next) fprintf(fp,", ");
47479 }
47480 fprintf(fp," }\n");
47481 return 0;
47482 }
47483
47484 static PyObject *
47485 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47486 swig_globalvar *var = v->vars;
47487 while (var) {
47488 if (strcmp(var->name,n) == 0) {
47489 return (*var->get_attr)();
47490 }
47491 var = var->next;
47492 }
47493 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47494 return NULL;
47495 }
47496
47497 static int
47498 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47499 swig_globalvar *var = v->vars;
47500 while (var) {
47501 if (strcmp(var->name,n) == 0) {
47502 return (*var->set_attr)(p);
47503 }
47504 var = var->next;
47505 }
47506 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47507 return 1;
47508 }
47509
47510 static PyTypeObject varlinktype = {
47511 PyObject_HEAD_INIT(0)
47512 0, /* Number of items in variable part (ob_size) */
47513 (char *)"swigvarlink", /* Type name (tp_name) */
47514 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47515 0, /* Itemsize (tp_itemsize) */
47516 0, /* Deallocator (tp_dealloc) */
47517 (printfunc) swig_varlink_print, /* Print (tp_print) */
47518 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47519 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47520 0, /* tp_compare */
47521 (reprfunc) swig_varlink_repr, /* tp_repr */
47522 0, /* tp_as_number */
47523 0, /* tp_as_sequence */
47524 0, /* tp_as_mapping */
47525 0, /* tp_hash */
47526 0, /* tp_call */
47527 0, /* tp_str */
47528 0, /* tp_getattro */
47529 0, /* tp_setattro */
47530 0, /* tp_as_buffer */
47531 0, /* tp_flags */
47532 0, /* tp_doc */
47533 #if PY_VERSION_HEX >= 0x02000000
47534 0, /* tp_traverse */
47535 0, /* tp_clear */
47536 #endif
47537 #if PY_VERSION_HEX >= 0x02010000
47538 0, /* tp_richcompare */
47539 0, /* tp_weaklistoffset */
47540 #endif
47541 #if PY_VERSION_HEX >= 0x02020000
47542 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47543 #endif
47544 #if PY_VERSION_HEX >= 0x02030000
47545 0, /* tp_del */
47546 #endif
47547 #ifdef COUNT_ALLOCS
47548 0,0,0,0 /* tp_alloc -> tp_next */
47549 #endif
47550 };
47551
47552 /* Create a variable linking object for use later */
47553 static PyObject *
47554 SWIG_Python_newvarlink(void) {
47555 swig_varlinkobject *result = 0;
47556 result = PyMem_NEW(swig_varlinkobject,1);
47557 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47558 result->ob_type = &varlinktype;
47559 result->vars = 0;
47560 result->ob_refcnt = 0;
47561 Py_XINCREF((PyObject *) result);
47562 return ((PyObject*) result);
47563 }
47564
47565 static void
47566 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47567 swig_varlinkobject *v;
47568 swig_globalvar *gv;
47569 v= (swig_varlinkobject *) p;
47570 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47571 gv->name = (char *) malloc(strlen(name)+1);
47572 strcpy(gv->name,name);
47573 gv->get_attr = get_attr;
47574 gv->set_attr = set_attr;
47575 gv->next = v->vars;
47576 v->vars = gv;
47577 }
47578
47579 /* -----------------------------------------------------------------------------
47580 * constants/methods manipulation
47581 * ----------------------------------------------------------------------------- */
47582
47583 /* Install Constants */
47584 static void
47585 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47586 PyObject *obj = 0;
47587 size_t i;
47588 for (i = 0; constants[i].type; i++) {
47589 switch(constants[i].type) {
47590 case SWIG_PY_INT:
47591 obj = PyInt_FromLong(constants[i].lvalue);
47592 break;
47593 case SWIG_PY_FLOAT:
47594 obj = PyFloat_FromDouble(constants[i].dvalue);
47595 break;
47596 case SWIG_PY_STRING:
47597 if (constants[i].pvalue) {
47598 obj = PyString_FromString((char *) constants[i].pvalue);
47599 } else {
47600 Py_INCREF(Py_None);
47601 obj = Py_None;
47602 }
47603 break;
47604 case SWIG_PY_POINTER:
47605 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47606 break;
47607 case SWIG_PY_BINARY:
47608 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47609 break;
47610 default:
47611 obj = 0;
47612 break;
47613 }
47614 if (obj) {
47615 PyDict_SetItemString(d,constants[i].name,obj);
47616 Py_DECREF(obj);
47617 }
47618 }
47619 }
47620
47621 /* -----------------------------------------------------------------------------*/
47622 /* Fix SwigMethods to carry the callback ptrs when needed */
47623 /* -----------------------------------------------------------------------------*/
47624
47625 static void
47626 SWIG_Python_FixMethods(PyMethodDef *methods,
47627 swig_const_info *const_table,
47628 swig_type_info **types,
47629 swig_type_info **types_initial) {
47630 size_t i;
47631 for (i = 0; methods[i].ml_name; ++i) {
47632 char *c = methods[i].ml_doc;
47633 if (c && (c = strstr(c, "swig_ptr: "))) {
47634 int j;
47635 swig_const_info *ci = 0;
47636 char *name = c + 10;
47637 for (j = 0; const_table[j].type; j++) {
47638 if (strncmp(const_table[j].name, name,
47639 strlen(const_table[j].name)) == 0) {
47640 ci = &(const_table[j]);
47641 break;
47642 }
47643 }
47644 if (ci) {
47645 size_t shift = (ci->ptype) - types;
47646 swig_type_info *ty = types_initial[shift];
47647 size_t ldoc = (c - methods[i].ml_doc);
47648 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47649 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47650 char *buff = ndoc;
47651 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47652 strncpy(buff, methods[i].ml_doc, ldoc);
47653 buff += ldoc;
47654 strncpy(buff, "swig_ptr: ", 10);
47655 buff += 10;
47656 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47657 methods[i].ml_doc = ndoc;
47658 }
47659 }
47660 }
47661 }
47662
47663 /* -----------------------------------------------------------------------------*
47664 * Initialize type list
47665 * -----------------------------------------------------------------------------*/
47666
47667 #if PY_MAJOR_VERSION < 2
47668 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47669 is copied out of Python/modsupport.c in python version 2.3.4 */
47670 static int
47671 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47672 {
47673 PyObject *dict;
47674 if (!PyModule_Check(m)) {
47675 PyErr_SetString(PyExc_TypeError,
47676 "PyModule_AddObject() needs module as first arg");
47677 return -1;
47678 }
47679 if (!o) {
47680 PyErr_SetString(PyExc_TypeError,
47681 "PyModule_AddObject() needs non-NULL value");
47682 return -1;
47683 }
47684
47685 dict = PyModule_GetDict(m);
47686 if (dict == NULL) {
47687 /* Internal error -- modules must have a dict! */
47688 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47689 PyModule_GetName(m));
47690 return -1;
47691 }
47692 if (PyDict_SetItemString(dict, name, o))
47693 return -1;
47694 Py_DECREF(o);
47695 return 0;
47696 }
47697 #endif
47698
47699 static swig_type_info **
47700 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47701 static PyMethodDef swig_empty_runtime_method_table[] = {
47702 {
47703 NULL, NULL, 0, NULL
47704 }
47705 };/* Sentinel */
47706
47707 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47708 swig_empty_runtime_method_table);
47709 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47710 if (pointer && module) {
47711 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47712 }
47713 return type_list_handle;
47714 }
47715
47716 static swig_type_info **
47717 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47718 swig_type_info **type_pointer;
47719
47720 /* first check if module already created */
47721 type_pointer = SWIG_Python_GetTypeListHandle();
47722 if (type_pointer) {
47723 return type_pointer;
47724 } else {
47725 /* create a new module and variable */
47726 return SWIG_Python_SetTypeListHandle(type_list_handle);
47727 }
47728 }
47729
47730 #ifdef __cplusplus
47731 }
47732 #endif
47733
47734 /* -----------------------------------------------------------------------------*
47735 * Partial Init method
47736 * -----------------------------------------------------------------------------*/
47737
47738 #ifdef SWIG_LINK_RUNTIME
47739 #ifdef __cplusplus
47740 extern "C"
47741 #endif
47742 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47743 #endif
47744
47745 #ifdef __cplusplus
47746 extern "C"
47747 #endif
47748 SWIGEXPORT(void) SWIG_init(void) {
47749 static PyObject *SWIG_globals = 0;
47750 static int typeinit = 0;
47751 PyObject *m, *d;
47752 int i;
47753 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47754
47755 /* Fix SwigMethods to carry the callback ptrs when needed */
47756 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47757
47758 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47759 d = PyModule_GetDict(m);
47760
47761 if (!typeinit) {
47762 #ifdef SWIG_LINK_RUNTIME
47763 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47764 #else
47765 # ifndef SWIG_STATIC_RUNTIME
47766 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47767 # endif
47768 #endif
47769 for (i = 0; swig_types_initial[i]; i++) {
47770 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47771 }
47772 typeinit = 1;
47773 }
47774 SWIG_InstallConstants(d,swig_const_table);
47775
47776
47777 #ifndef wxPyUSE_EXPORT
47778 // Make our API structure a CObject so other modules can import it
47779 // from this module.
47780 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47781 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47782 Py_XDECREF(cobj);
47783 #endif
47784
47785 {
47786 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49449 }
49450 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49451 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49452 {
49453 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49604 }
49605 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49606 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49607 {
49608 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49615 }
49616
49617 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49618
49619
49620 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49621
49622 {
49623 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49630 }
49631 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49632 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49633 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49634 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49635 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49636 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49637 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49638 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49639 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49640 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49641 {
49642 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49646 }
49647 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49648 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49649 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49650 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49651 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49652 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49653 {
49654 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49700 }
49701 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49702 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49703 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49704 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49705 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49706 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49707 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49708 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49709 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49710 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49711 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49712 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49713 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49714 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49715 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49716 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49717 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49718 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49719 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49720 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49721 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49722 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49723 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49724 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49725 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49726 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49727 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49728 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49729 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49730 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49731 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49732 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49733 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49734 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49735 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49736 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49737 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49738 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49739 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49740 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49741 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49742 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49743 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49744 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49745 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49746 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49747 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49748 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49749 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49750 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49751 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49752 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49753 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49754 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49755 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49756 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49757 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49758 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49759 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49760 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49761 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49762 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49763 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49764 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49765 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49766 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49767 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49768 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49769 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49770 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49771 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49772 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49773 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49774 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49775 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49776 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49777 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49778 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49779 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49780 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49781 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49782 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49783 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49784 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49785 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49786 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49787 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49788 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49789 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49790 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49791 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49792 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49793 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49794 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49795 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49796 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49797 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49798 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49799 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49800 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49801 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49802 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49803 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49804 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49805 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49806 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49807 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49808 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49809 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49810 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49811 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49812 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49813 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49814 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49815 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49816 {
49817 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49854 }
49855 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49856 {
49857 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49873 }
49874 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49875 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49876 {
49877 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49890 }
49891 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49892 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49893 {
49894 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49901 }
49902 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49903 {
49904 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49959 }
49960
49961 // Initialize threading, some globals and such
49962 __wxPyPreStart(d);
49963
49964
49965 // Although these are defined in __version__ they need to be here too so
49966 // that an assert can be done to ensure that the wxPython and the wxWindows
49967 // versions match.
49968 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49969 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49970 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49971
49972 }
49973
wxWidgets (Impactor)